diff --git a/build-tools/build-tools.iml b/build-tools/build-tools.iml index 61383bdd557..d184270053f 100644 --- a/build-tools/build-tools.iml +++ b/build-tools/build-tools.iml @@ -9,6 +9,7 @@ + diff --git a/build-tools/core/src/org/jetbrains/jet/buildtools/core/BytecodeCompiler.java b/build-tools/core/src/org/jetbrains/jet/buildtools/core/BytecodeCompiler.java index 6a65f9ff739..3045f3b454e 100644 --- a/build-tools/core/src/org/jetbrains/jet/buildtools/core/BytecodeCompiler.java +++ b/build-tools/core/src/org/jetbrains/jet/buildtools/core/BytecodeCompiler.java @@ -21,6 +21,8 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.compiler.CompileEnvironment; import org.jetbrains.jet.compiler.CompileEnvironmentException; import org.jetbrains.jet.compiler.CompilerPlugin; +import org.jetbrains.jet.lang.resolve.java.CompilerDependencies; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import java.io.File; import java.util.ArrayList; @@ -47,7 +49,7 @@ public class BytecodeCompiler { * @return compile environment instance */ private CompileEnvironment env( String stdlib, String[] classpath ) { - CompileEnvironment env = new CompileEnvironment(); + CompileEnvironment env = new CompileEnvironment(CompilerDependencies.compilerDependenciesForProduction(CompilerSpecialMode.REGULAR)); if (( stdlib != null ) && ( stdlib.trim().length() > 0 )) { env.setStdlib( stdlib ); diff --git a/compiler/cli/src/org/jetbrains/jet/cli/CompilerArguments.java b/compiler/cli/src/org/jetbrains/jet/cli/CompilerArguments.java index 712f4a4eb9f..ee233809581 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/CompilerArguments.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/CompilerArguments.java @@ -61,6 +61,9 @@ public class CompilerArguments { @Argument(value = "stdlib", description = "Path to the stdlib.jar") public String stdlib; + @Argument(value = "jdkHeaders", description = "Path to the kotlin-jdk-headers.jar") + public String jdkHeaders; + @Argument(value = "help", alias = "h", description = "show help") public boolean help; diff --git a/compiler/cli/src/org/jetbrains/jet/cli/KotlinCompiler.java b/compiler/cli/src/org/jetbrains/jet/cli/KotlinCompiler.java index 8d2d9edea58..9e64a6e3b2d 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/KotlinCompiler.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/KotlinCompiler.java @@ -24,7 +24,9 @@ import org.jetbrains.jet.compiler.CompileEnvironmentException; import org.jetbrains.jet.compiler.CompilerPlugin; import org.jetbrains.jet.compiler.MessageRenderer; import org.jetbrains.jet.lang.diagnostics.Severity; +import org.jetbrains.jet.lang.resolve.java.CompilerDependencies; import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; +import org.jetbrains.jet.utils.PathUtil; import java.io.File; import java.io.PrintStream; @@ -121,7 +123,32 @@ public class KotlinCompiler { } } - CompileEnvironment environment = new CompileEnvironment(messageRenderer, arguments.verbose, mode); + File jdkHeadersJar; + if (mode.includeJdkHeaders()) { + if (arguments.jdkHeaders != null) { + jdkHeadersJar = new File(arguments.jdkHeaders); + } else { + jdkHeadersJar = PathUtil.getAltHeadersPath(); + } + } + else { + jdkHeadersJar = null; + } + File runtimeJar; + + if (mode.includeKotlinRuntime()) { + if (arguments.stdlib != null) { + runtimeJar = new File(arguments.stdlib); + } else { + runtimeJar = PathUtil.getDefaultRuntimePath(); + } + } + else { + runtimeJar = null; + } + + CompilerDependencies dependencies = new CompilerDependencies(mode, jdkHeadersJar,runtimeJar); + CompileEnvironment environment = new CompileEnvironment(messageRenderer, arguments.verbose, dependencies); try { configureEnvironment(environment, arguments, errStream); @@ -204,8 +231,8 @@ public class KotlinCompiler { environment.getEnvironment().getCompilerPlugins().addAll(plugins); } - if (arguments.stdlib != null) { - environment.setStdlib(arguments.stdlib); + if (environment.getCompilerDependencies().getRuntimeJar() != null) { + environment.addToClasspath(environment.getCompilerDependencies().getRuntimeJar()); } if (arguments.classpath != null) { diff --git a/compiler/cli/src/org/jetbrains/jet/compiler/CompileEnvironment.java b/compiler/cli/src/org/jetbrains/jet/compiler/CompileEnvironment.java index 1d1445118dd..cf6c676be98 100644 --- a/compiler/cli/src/org/jetbrains/jet/compiler/CompileEnvironment.java +++ b/compiler/cli/src/org/jetbrains/jet/compiler/CompileEnvironment.java @@ -17,7 +17,6 @@ package org.jetbrains.jet.compiler; import com.intellij.openapi.Disposable; -import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Disposer; import com.intellij.openapi.util.io.FileUtil; import com.intellij.psi.JavaPsiFacade; @@ -34,20 +33,31 @@ import org.jetbrains.jet.codegen.GeneratedClassLoader; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetPsiUtil; import org.jetbrains.jet.lang.resolve.FqName; +import org.jetbrains.jet.lang.resolve.java.CompilerDependencies; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import org.jetbrains.jet.lang.resolve.java.JvmAbi; import org.jetbrains.jet.plugin.JetLanguage; import org.jetbrains.jet.plugin.JetMainDetector; -import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import org.jetbrains.jet.utils.PathUtil; -import java.io.*; +import java.io.File; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.OutputStream; +import java.io.PrintStream; import java.lang.reflect.Method; import java.net.MalformedURLException; import java.net.URL; import java.net.URLClassLoader; import java.util.ArrayList; import java.util.List; -import java.util.jar.*; +import java.util.jar.Attributes; +import java.util.jar.JarEntry; +import java.util.jar.JarInputStream; +import java.util.jar.JarOutputStream; +import java.util.jar.Manifest; /** * The environment for compiling a bunch of source files or @@ -60,32 +70,28 @@ public class CompileEnvironment { private final MessageRenderer messageRenderer; private PrintStream errorStream = System.err; - private URL stdlibUrl; - private boolean ignoreErrors = false; - private final CompilerSpecialMode mode; + @NotNull + private final CompilerDependencies compilerDependencies; private final boolean verbose; - public CompileEnvironment() { - this(MessageRenderer.PLAIN, false, CompilerSpecialMode.REGULAR); + public CompileEnvironment(CompilerDependencies compilerDependencies) { + this(MessageRenderer.PLAIN, false, compilerDependencies); } /** * NOTE: It's very important to call dispose for every object of this class or there will be memory leaks. * @see Disposer - * - * @param messageRenderer - * @param verbose */ - public CompileEnvironment(MessageRenderer messageRenderer, boolean verbose, CompilerSpecialMode mode) { - this.mode = mode; + public CompileEnvironment(MessageRenderer messageRenderer, boolean verbose, @NotNull CompilerDependencies compilerDependencies) { + this.compilerDependencies = compilerDependencies; this.verbose = verbose; rootDisposable = new Disposable() { @Override public void dispose() { } }; - environment = new JetCoreEnvironment(rootDisposable, mode.includeJdkHeaders()); + environment = new JetCoreEnvironment(rootDisposable, compilerDependencies); this.messageRenderer = messageRenderer; } @@ -121,22 +127,21 @@ public class CompileEnvironment { } public void ensureRuntime() { - if (mode == CompilerSpecialMode.REGULAR) { + if (compilerDependencies.getCompilerSpecialMode() == CompilerSpecialMode.REGULAR) { ensureRuntime(environment); - } else if (mode == CompilerSpecialMode.JDK_HEADERS) { + } else if (compilerDependencies.getCompilerSpecialMode() == CompilerSpecialMode.JDK_HEADERS) { ensureJdkRuntime(environment); - } else if (mode == CompilerSpecialMode.STDLIB) { + } else if (compilerDependencies.getCompilerSpecialMode() == CompilerSpecialMode.STDLIB) { ensureJdkRuntime(environment); - } else if (mode == CompilerSpecialMode.BUILTINS) { + } else if (compilerDependencies.getCompilerSpecialMode() == CompilerSpecialMode.BUILTINS) { // nop } else { - throw new IllegalStateException("unknown mode: " + mode); + throw new IllegalStateException("unknown mode: " + compilerDependencies.getCompilerSpecialMode()); } } public static void ensureRuntime(@NotNull JetCoreEnvironment env) { ensureJdkRuntime(env); - ensureKotlinRuntime(env); } private static void ensureKotlinRuntime(JetCoreEnvironment env) { @@ -192,8 +197,6 @@ public class CompileEnvironment { public boolean compileModuleScript(String moduleScriptFile, @Nullable String jarPath, @Nullable String outputDir, boolean jarRuntime) { CompileEnvironment moduleCompilationEnvironment = copyEnvironment(false); try { - moduleCompilationEnvironment.stdlibUrl = stdlibUrl; - List modules = moduleCompilationEnvironment.loadModuleScript(moduleScriptFile); if (modules == null) { @@ -207,6 +210,9 @@ public class CompileEnvironment { final String directory = new File(moduleScriptFile).getParent(); for (Module moduleBuilder : modules) { CompileEnvironment compileEnvironment = copyEnvironment(verbose); + if (compilerDependencies.getRuntimeJar() != null) { + compileEnvironment.addToClasspath(compilerDependencies.getRuntimeJar()); + } try { ClassFileFactory moduleFactory = compileEnvironment.compileModule(moduleBuilder, directory); if (moduleFactory == null) { @@ -234,7 +240,7 @@ public class CompileEnvironment { } private CompileEnvironment copyEnvironment(boolean verbose) { - CompileEnvironment compileEnvironment = new CompileEnvironment(messageRenderer, verbose, mode); + CompileEnvironment compileEnvironment = new CompileEnvironment(messageRenderer, verbose, compilerDependencies); compileEnvironment.setIgnoreErrors(ignoreErrors); compileEnvironment.setErrorStream(errorStream); // copy across any compiler plugins @@ -247,6 +253,10 @@ public class CompileEnvironment { scriptCompileSession.addSources(moduleFile); ensureRuntime(); + if (compilerDependencies.getRuntimeJar() != null) { + addToClasspath(compilerDependencies.getRuntimeJar()); + } + if (!scriptCompileSession.analyze()) { return null; } @@ -256,8 +266,18 @@ public class CompileEnvironment { } private List runDefineModules(String moduleFile, ClassFileFactory factory) { - GeneratedClassLoader loader = stdlibUrl != null ? new GeneratedClassLoader(factory, new URLClassLoader(new URL[] {stdlibUrl}, AllModules.class.getClassLoader())) - : new GeneratedClassLoader(factory, CompileEnvironment.class.getClassLoader()); + File stdlibJar = compilerDependencies.getRuntimeJar(); + GeneratedClassLoader loader; + if (stdlibJar != null) { + try { + loader = new GeneratedClassLoader(factory, new URLClassLoader(new URL[]{stdlibJar.toURI().toURL()}, AllModules.class.getClassLoader())); + } catch (MalformedURLException e) { + throw new RuntimeException(e); + } + } + else { + loader = new GeneratedClassLoader(factory, CompileEnvironment.class.getClassLoader()); + } try { Class namespaceClass = loader.loadClass(JvmAbi.PACKAGE_CLASS); final Method method = namespaceClass.getDeclaredMethod("project"); @@ -282,7 +302,7 @@ public class CompileEnvironment { public ClassFileFactory compileModule(Module moduleBuilder, String directory) { CompileSession moduleCompileSession = newCompileSession(); - moduleCompileSession.setStubs(mode.isStubs()); + moduleCompileSession.setStubs(compilerDependencies.getCompilerSpecialMode().isStubs()); if (moduleBuilder.getSourceFiles().isEmpty()) { throw new CompileEnvironmentException("No source files where defined"); @@ -403,7 +423,7 @@ public class CompileEnvironment { public boolean compileBunchOfSources(String sourceFileOrDir, String jar, String outputDir, boolean includeRuntime) { CompileSession session = newCompileSession(); - session.setStubs(mode.isStubs()); + session.setStubs(compilerDependencies.getCompilerSpecialMode().isStubs()); session.addSources(sourceFileOrDir); @@ -412,7 +432,7 @@ public class CompileEnvironment { public boolean compileBunchOfSourceDirectories(List sources, String jar, String outputDir, boolean includeRuntime) { CompileSession session = newCompileSession(); - session.setStubs(mode.isStubs()); + session.setStubs(compilerDependencies.getCompilerSpecialMode().isStubs()); for (String source : sources) { session.addSources(source); @@ -455,7 +475,7 @@ public class CompileEnvironment { } private CompileSession newCompileSession() { - CompileSession answer = new CompileSession(environment, messageRenderer, errorStream, verbose, mode); + CompileSession answer = new CompileSession(environment, messageRenderer, errorStream, verbose, compilerDependencies); environment.setSession(answer); return answer; } @@ -499,16 +519,14 @@ public class CompileEnvironment { public void setStdlib(String stdlib) { File file = new File(stdlib); addToClasspath(file); - - try { - stdlibUrl = file.toURL(); - } - catch (MalformedURLException e) { - throw new RuntimeException(e); - } } public JetCoreEnvironment getEnvironment() { return environment; } + + @NotNull + public CompilerDependencies getCompilerDependencies() { + return compilerDependencies; + } } diff --git a/compiler/cli/src/org/jetbrains/jet/compiler/CompileSession.java b/compiler/cli/src/org/jetbrains/jet/compiler/CompileSession.java index 53e2ce87a40..55b7d08a788 100644 --- a/compiler/cli/src/org/jetbrains/jet/compiler/CompileSession.java +++ b/compiler/cli/src/org/jetbrains/jet/compiler/CompileSession.java @@ -43,7 +43,7 @@ import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.java.AnalyzeExhaust; import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; -import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; +import org.jetbrains.jet.lang.resolve.java.CompilerDependencies; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.plugin.JetFileType; import org.jetbrains.jet.utils.Progress; @@ -68,15 +68,16 @@ public class CompileSession { private final MessageRenderer messageRenderer; private final PrintStream errorStream; private final boolean isVerbose; - private final CompilerSpecialMode compilerSpecialMode; + private final CompilerDependencies compilerDependencies; private AnalyzeExhaust bindingContext; - public CompileSession(JetCoreEnvironment environment, MessageRenderer messageRenderer, PrintStream errorStream, boolean verbose, CompilerSpecialMode mode) { + public CompileSession(JetCoreEnvironment environment, MessageRenderer messageRenderer, PrintStream errorStream, boolean verbose, + @NotNull CompilerDependencies compilerDependencies) { this.environment = environment; this.messageRenderer = messageRenderer; this.errorStream = errorStream; isVerbose = verbose; - this.compilerSpecialMode = mode; + this.compilerDependencies = compilerDependencies; messageCollector = new MessageCollector(this.messageRenderer); } @@ -176,7 +177,8 @@ public class CompileSession { Predicate filesToAnalyzeCompletely = stubs ? Predicates.alwaysFalse() : Predicates.alwaysTrue(); bindingContext = AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration( - environment.getProject(), sourceFiles, filesToAnalyzeCompletely, JetControlFlowDataTraceFactory.EMPTY, compilerSpecialMode); + environment.getProject(), sourceFiles, filesToAnalyzeCompletely, JetControlFlowDataTraceFactory.EMPTY, + compilerDependencies); for (Diagnostic diagnostic : bindingContext.getBindingContext().getDiagnostics()) { reportDiagnostic(messageCollector, diagnostic); @@ -221,7 +223,7 @@ public class CompileSession { public GenerationState generate(boolean module) { Project project = environment.getProject(); GenerationState generationState = new GenerationState(project, ClassBuilderFactories.binaries(stubs), - isVerbose ? new BackendProgress() : Progress.DEAF, bindingContext, sourceFiles, compilerSpecialMode); + isVerbose ? new BackendProgress() : Progress.DEAF, bindingContext, sourceFiles, compilerDependencies.getCompilerSpecialMode()); generationState.compileCorrectFiles(CompilationErrorHandler.THROW_EXCEPTION); List plugins = environment.getCompilerPlugins(); diff --git a/compiler/cli/src/org/jetbrains/jet/compiler/JetCoreEnvironment.java b/compiler/cli/src/org/jetbrains/jet/compiler/JetCoreEnvironment.java index fab044d0abb..0feec9530a6 100644 --- a/compiler/cli/src/org/jetbrains/jet/compiler/JetCoreEnvironment.java +++ b/compiler/cli/src/org/jetbrains/jet/compiler/JetCoreEnvironment.java @@ -23,8 +23,11 @@ import com.intellij.openapi.Disposable; import com.intellij.openapi.extensions.Extensions; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.psi.PsiElementFinder; +import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.asJava.JavaElementFinder; import org.jetbrains.jet.lang.parsing.JetParserDefinition; +import org.jetbrains.jet.lang.resolve.java.CompilerDependencies; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import org.jetbrains.jet.lang.resolve.java.JetFilesProvider; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import org.jetbrains.jet.plugin.JetFileType; @@ -43,7 +46,7 @@ public class JetCoreEnvironment extends JavaCoreEnvironment { private List compilerPlugins = new ArrayList(); private CompileSession session; - public JetCoreEnvironment(Disposable parentDisposable, boolean includeJdkHeaders) { + public JetCoreEnvironment(Disposable parentDisposable, @NotNull CompilerDependencies compilerDependencies) { super(parentDisposable); registerFileType(JetFileType.INSTANCE, "kt"); registerFileType(JetFileType.INSTANCE, "kts"); @@ -58,8 +61,15 @@ public class JetCoreEnvironment extends JavaCoreEnvironment { .getExtensionPoint(PsiElementFinder.EP_NAME) .registerExtension(new JavaElementFinder(myProject)); - if (includeJdkHeaders) { - for (VirtualFile root : PathUtil.getAltHeadersRoots()) { + CompilerSpecialMode compilerSpecialMode = compilerDependencies.getCompilerSpecialMode(); + + if (compilerSpecialMode.includeJdkHeaders()) { + for (VirtualFile root : compilerDependencies.getJdkHeaderRoots()) { + addLibraryRoot(root); + } + } + if (compilerSpecialMode.includeKotlinRuntime()) { + for (VirtualFile root : compilerDependencies.getRuntimeRoots()) { addLibraryRoot(root); } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java index f063431b952..7ff65b75d00 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java @@ -23,10 +23,12 @@ import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.java.JavaBridgeConfiguration; import org.jetbrains.jet.lang.resolve.java.PsiClassFinderForJvm; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; +import org.jetbrains.jet.lang.resolve.java.CompilerDependencies; import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import com.intellij.openapi.project.Project; import org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer; import org.jetbrains.jet.lang.resolve.NamespaceFactoryImpl; +import org.jetbrains.jet.lang.resolve.java.CompilerDependencies; import com.intellij.openapi.project.Project; import org.jetbrains.annotations.NotNull; @@ -40,6 +42,7 @@ public class InjectorForJavaSemanticServices { private final Project project; public InjectorForJavaSemanticServices( + @NotNull CompilerDependencies compilerDependencies, @NotNull Project project ) { this.javaSemanticServices = new JavaSemanticServices(); @@ -48,7 +51,7 @@ public class InjectorForJavaSemanticServices { JavaBridgeConfiguration javaBridgeConfiguration = new JavaBridgeConfiguration(); this.psiClassFinderForJvm = new PsiClassFinderForJvm(); ModuleDescriptor moduleDescriptor = new org.jetbrains.jet.lang.descriptors.ModuleDescriptor(""); - CompilerSpecialMode compilerSpecialMode = CompilerSpecialMode.REGULAR; + CompilerSpecialMode compilerSpecialMode = compilerDependencies.getCompilerSpecialMode(); this.project = project; JavaTypeTransformer javaTypeTransformer = new JavaTypeTransformer(); NamespaceFactoryImpl namespaceFactoryImpl = new NamespaceFactoryImpl(); @@ -68,7 +71,7 @@ public class InjectorForJavaSemanticServices { javaBridgeConfiguration.setMode(compilerSpecialMode); javaBridgeConfiguration.setProject(project); - this.psiClassFinderForJvm.setCompilerSpecialMode(compilerSpecialMode); + this.psiClassFinderForJvm.setCompilerDependencies(compilerDependencies); this.psiClassFinderForJvm.setProject(project); javaTypeTransformer.setJavaSemanticServices(javaSemanticServices); 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 098f19e22e5..f90be7eefc1 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java @@ -28,6 +28,7 @@ import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters; import org.jetbrains.jet.lang.resolve.ObservableBindingTrace; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; +import org.jetbrains.jet.lang.resolve.java.CompilerDependencies; import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import org.jetbrains.jet.lang.resolve.java.JavaBridgeConfiguration; import org.jetbrains.jet.lang.resolve.java.PsiClassFinderForJvm; @@ -52,7 +53,7 @@ import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters; import org.jetbrains.jet.lang.resolve.ObservableBindingTrace; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; -import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; +import org.jetbrains.jet.lang.resolve.java.CompilerDependencies; import org.jetbrains.annotations.NotNull; /* This file is generated by org.jetbrains.jet.di.AllInjectorsGenerator. DO NOT EDIT! */ @@ -75,7 +76,7 @@ public class InjectorForTopDownAnalyzerForJvm { @NotNull ObservableBindingTrace observableBindingTrace, @NotNull ModuleDescriptor moduleDescriptor, JetControlFlowDataTraceFactory jetControlFlowDataTraceFactory, - @NotNull CompilerSpecialMode compilerSpecialMode + @NotNull CompilerDependencies compilerDependencies ) { this.topDownAnalyzer = new TopDownAnalyzer(); this.topDownAnalysisContext = new TopDownAnalysisContext(); @@ -86,6 +87,7 @@ public class InjectorForTopDownAnalyzerForJvm { this.project = project; this.topDownAnalysisParameters = topDownAnalysisParameters; this.observableBindingTrace = observableBindingTrace; + CompilerSpecialMode compilerSpecialMode = compilerDependencies.getCompilerSpecialMode(); this.javaBridgeConfiguration = new JavaBridgeConfiguration(); PsiClassFinderForJvm psiClassFinderForJvm = new PsiClassFinderForJvm(); DeclarationResolver declarationResolver = new DeclarationResolver(); @@ -144,7 +146,7 @@ public class InjectorForTopDownAnalyzerForJvm { this.javaBridgeConfiguration.setMode(compilerSpecialMode); this.javaBridgeConfiguration.setProject(project); - psiClassFinderForJvm.setCompilerSpecialMode(compilerSpecialMode); + psiClassFinderForJvm.setCompilerDependencies(compilerDependencies); psiClassFinderForJvm.setProject(project); declarationResolver.setAnnotationResolver(annotationResolver); 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 b3ea52401c4..e43cee00569 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 @@ -71,7 +71,9 @@ public class AnalyzerFacadeForJVM { * @param declarationProvider * @return */ - public static AnalyzeExhaust analyzeFileWithCache(@NotNull final JetFile file, @NotNull final Function> declarationProvider) { + public static AnalyzeExhaust analyzeFileWithCache(@NotNull final JetFile file, + @NotNull final Function> declarationProvider, + @NotNull final CompilerSpecialMode compilerSpecialMode, @NotNull final CompilerDependencies compilerDependencies) { // Need lock for getValue(), because parallel threads can start evaluation of compute() simultaneously synchronized (lock) { CachedValue bindingContextCachedValue = file.getUserData(BINDING_CONTEXT); @@ -80,12 +82,13 @@ public class AnalyzerFacadeForJVM { @Override public Result compute() { try { - AnalyzeExhaust bindingContext = analyzeFilesWithJavaIntegration( + AnalyzeExhaust bindingContext; + bindingContext = analyzeFilesWithJavaIntegration( file.getProject(), declarationProvider.fun(file), Predicates.equalTo(file), JetControlFlowDataTraceFactory.EMPTY, - CompilerSpecialMode.REGULAR); + compilerDependencies); return new Result(bindingContext, PsiModificationTracker.MODIFICATION_COUNT); } catch (ProcessCanceledException e) { @@ -111,7 +114,9 @@ public class AnalyzerFacadeForJVM { * Analyze project with string cache for the whole project. All given files will be analyzed only for descriptors. */ public static AnalyzeExhaust analyzeProjectWithCache(@NotNull final Project project, - @NotNull final Collection files) { + @NotNull final Collection files, + @NotNull final CompilerSpecialMode compilerSpecialMode, + @NotNull final CompilerDependencies compilerDependencies) { // Need lock for getValue(), because parallel threads can start evaluation of compute() simultaneously synchronized (lock) { CachedValue bindingContextCachedValue = project.getUserData(BINDING_CONTEXT); @@ -125,7 +130,7 @@ public class AnalyzerFacadeForJVM { files, Predicates.alwaysFalse(), JetControlFlowDataTraceFactory.EMPTY, - CompilerSpecialMode.REGULAR); + compilerDependencies); return new Result(analyzeExhaust, PsiModificationTracker.MODIFICATION_COUNT); } catch (ProcessCanceledException e) { @@ -147,25 +152,28 @@ public class AnalyzerFacadeForJVM { } public static AnalyzeExhaust analyzeOneFileWithJavaIntegrationAndCheckForErrors( - JetFile file, JetControlFlowDataTraceFactory flowDataTraceFactory) { + JetFile file, JetControlFlowDataTraceFactory flowDataTraceFactory, + @NotNull CompilerSpecialMode compilerSpecialMode, @NotNull CompilerDependencies compilerDependencies) { AnalyzingUtils.checkForSyntacticErrors(file); - AnalyzeExhaust analyzeExhaust = analyzeOneFileWithJavaIntegration(file, flowDataTraceFactory); + AnalyzeExhaust analyzeExhaust = analyzeOneFileWithJavaIntegration(file, flowDataTraceFactory, compilerDependencies); AnalyzingUtils.throwExceptionOnErrors(analyzeExhaust.getBindingContext()); return analyzeExhaust; } - public static AnalyzeExhaust analyzeOneFileWithJavaIntegration(JetFile file, JetControlFlowDataTraceFactory flowDataTraceFactory) { + public static AnalyzeExhaust analyzeOneFileWithJavaIntegration( + JetFile file, JetControlFlowDataTraceFactory flowDataTraceFactory, + @NotNull CompilerDependencies compilerDependencies) { return analyzeFilesWithJavaIntegration(file.getProject(), Collections.singleton(file), - Predicates.alwaysTrue(), flowDataTraceFactory, CompilerSpecialMode.REGULAR); + Predicates.alwaysTrue(), flowDataTraceFactory, compilerDependencies); } public static AnalyzeExhaust analyzeFilesWithJavaIntegration( Project project, Collection files, Predicate filesToAnalyzeCompletely, JetControlFlowDataTraceFactory flowDataTraceFactory, - CompilerSpecialMode compilerSpecialMode) { + @NotNull CompilerDependencies compilerDependencies) { BindingTraceContext bindingTraceContext = new BindingTraceContext(); final ModuleDescriptor owner = new ModuleDescriptor(""); @@ -177,19 +185,20 @@ public class AnalyzerFacadeForJVM { InjectorForTopDownAnalyzerForJvm injector = new InjectorForTopDownAnalyzerForJvm( project, topDownAnalysisParameters, new ObservableBindingTrace(bindingTraceContext), owner, flowDataTraceFactory, - compilerSpecialMode); + compilerDependencies); injector.getTopDownAnalyzer().analyzeFiles(files); return new AnalyzeExhaust(bindingTraceContext.getBindingContext(), JetStandardLibrary.getInstance()); } - public static AnalyzeExhaust shallowAnalyzeFiles(Collection files) { + public static AnalyzeExhaust shallowAnalyzeFiles(Collection files, + @NotNull CompilerSpecialMode compilerSpecialMode, @NotNull CompilerDependencies compilerDependencies) { assert files.size() > 0; Project project = files.iterator().next().getProject(); return analyzeFilesWithJavaIntegration(project, files, Predicates.alwaysFalse(), - JetControlFlowDataTraceFactory.EMPTY, CompilerSpecialMode.REGULAR); + JetControlFlowDataTraceFactory.EMPTY, compilerDependencies); } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/CompilerDependencies.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/CompilerDependencies.java new file mode 100644 index 00000000000..125980fa3c0 --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/CompilerDependencies.java @@ -0,0 +1,98 @@ +/* + * Copyright 2010-2012 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.lang.resolve.java; + +import com.intellij.openapi.vfs.VirtualFile; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.utils.PathUtil; + +import java.io.File; +import java.util.Collections; +import java.util.List; + +/** + * @author Stepan Koltsov + */ +public class CompilerDependencies { + + @NotNull + private final CompilerSpecialMode compilerSpecialMode; + @Nullable + private final File jdkHeadersJar; + @Nullable + private final File runtimeJar; + + public CompilerDependencies(@NotNull CompilerSpecialMode compilerSpecialMode, @Nullable File jdkHeadersJar, @Nullable File runtimeJar) { + this.compilerSpecialMode = compilerSpecialMode; + this.jdkHeadersJar = jdkHeadersJar; + this.runtimeJar = runtimeJar; + + if (compilerSpecialMode.includeJdkHeaders()) { + if (jdkHeadersJar == null) { + throw new IllegalArgumentException("jdkHeaders must be included for mode " + compilerSpecialMode); + } + } + if (compilerSpecialMode.includeKotlinRuntime()) { + if (runtimeJar == null) { + throw new IllegalArgumentException("runtime must be include for mode " + compilerSpecialMode); + } + } + } + + @NotNull + public CompilerSpecialMode getCompilerSpecialMode() { + return compilerSpecialMode; + } + + @Nullable + public File getJdkHeadersJar() { + return jdkHeadersJar; + } + + @Nullable + public File getRuntimeJar() { + return runtimeJar; + } + + @NotNull + public List getJdkHeaderRoots() { + if (compilerSpecialMode.includeJdkHeaders()) { + return Collections.singletonList(PathUtil.jarFileToVirtualFile(jdkHeadersJar)); + } else { + return Collections.emptyList(); + } + } + + @NotNull + public List getRuntimeRoots() { + if (compilerSpecialMode.includeKotlinRuntime()) { + return Collections.singletonList(PathUtil.jarFileToVirtualFile(runtimeJar)); + } else { + return Collections.emptyList(); + } + } + + @NotNull + public static CompilerDependencies compilerDependenciesForProduction(@NotNull CompilerSpecialMode compilerSpecialMode) { + return new CompilerDependencies( + compilerSpecialMode, + compilerSpecialMode.includeJdkHeaders() ? PathUtil.getAltHeadersPath() : null, + compilerSpecialMode.includeKotlinRuntime() ? PathUtil.getDefaultRuntimePath() : null); + } + +} diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/CompilerSpecialMode.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/CompilerSpecialMode.java index 4fa7a42372c..a92c9abb47f 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/CompilerSpecialMode.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/CompilerSpecialMode.java @@ -30,6 +30,10 @@ public enum CompilerSpecialMode { return this == REGULAR || this == STDLIB; } + public boolean includeKotlinRuntime() { + return this == REGULAR; + } + public boolean isStubs() { return this == BUILTINS || this == JDK_HEADERS; } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PsiClassFinderForJvm.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PsiClassFinderForJvm.java index dc20e415340..26f81a9650c 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PsiClassFinderForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PsiClassFinderForJvm.java @@ -43,7 +43,7 @@ public class PsiClassFinderForJvm implements PsiClassFinder { @NotNull private Project project; @NotNull - private CompilerSpecialMode compilerSpecialMode; + private CompilerDependencies compilerDependencies; private AltClassFinder altClassFinder; private GlobalSearchScope javaSearchScope; @@ -55,14 +55,13 @@ public class PsiClassFinderForJvm implements PsiClassFinder { } @Inject - public void setCompilerSpecialMode(@NotNull CompilerSpecialMode compilerSpecialMode) { - this.compilerSpecialMode = compilerSpecialMode; + public void setCompilerDependencies(@NotNull CompilerDependencies compilerDependencies) { + this.compilerDependencies = compilerDependencies; } @PostConstruct public void initialize() { - this.altClassFinder = new AltClassFinder(project, - compilerSpecialMode.includeJdkHeaders() ? PathUtil.getAltHeadersRoots() : Collections.emptyList()); + this.altClassFinder = new AltClassFinder(project, compilerDependencies.getJdkHeaderRoots()); this.javaSearchScope = new DelegatingGlobalSearchScope(GlobalSearchScope.allScope(project)) { @Override public boolean contains(VirtualFile file) { diff --git a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/JetLightClass.java b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/JetLightClass.java index ed3b3ed3888..3d8e50eb30f 100644 --- a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/JetLightClass.java +++ b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/JetLightClass.java @@ -50,6 +50,8 @@ import org.jetbrains.jet.lang.psi.JetPsiUtil; import org.jetbrains.jet.lang.resolve.FqName; import org.jetbrains.jet.lang.resolve.java.AnalyzeExhaust; import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; +import org.jetbrains.jet.lang.resolve.java.CompilerDependencies; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import org.jetbrains.jet.lang.resolve.java.JetFilesProvider; import org.jetbrains.jet.lang.resolve.java.JetJavaMirrorMarker; import org.jetbrains.jet.plugin.JetLanguage; @@ -159,7 +161,9 @@ public class JetLightClass extends AbstractLightClass implements JetJavaMirrorMa // Otherwise, the analyzer gets confused and can't, for example, tell which files come as sources and which // must be loaded from .class files AnalyzeExhaust context = AnalyzerFacadeForJVM.shallowAnalyzeFiles( - JetFilesProvider.getInstance(project).sampleToAllFilesInModule().fun(file)); + JetFilesProvider.getInstance(project).sampleToAllFilesInModule().fun(file), + // TODO: wrong environment // stepan.koltsov@ 2012-04-09 + CompilerSpecialMode.REGULAR, CompilerDependencies.compilerDependenciesForProduction(CompilerSpecialMode.REGULAR)); final GenerationState state = new GenerationState(project, builderFactory, context, Collections.singletonList(file)) { @Override diff --git a/compiler/tests/org/jetbrains/jet/CompileCompilerDependenciesTest.java b/compiler/tests/org/jetbrains/jet/CompileCompilerDependenciesTest.java index 8e69566607e..e6178f6d2bd 100644 --- a/compiler/tests/org/jetbrains/jet/CompileCompilerDependenciesTest.java +++ b/compiler/tests/org/jetbrains/jet/CompileCompilerDependenciesTest.java @@ -16,9 +16,13 @@ package org.jetbrains.jet; +import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileBuiltins; import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileJdkHeaders; import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileRuntime; +import org.jetbrains.jet.lang.resolve.java.CompilerDependencies; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; +import org.jetbrains.jet.utils.PathUtil; import org.junit.Test; /** @@ -41,4 +45,14 @@ public class CompileCompilerDependenciesTest { ForTestCompileRuntime.runtimeJarForTests(); } + /** + * @see CompilerDependencies#compilerDependenciesForProduction(org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode) + */ + @NotNull + public static CompilerDependencies compilerDependenciesForTests(@NotNull CompilerSpecialMode compilerSpecialMode) { + return new CompilerDependencies( + compilerSpecialMode, + compilerSpecialMode.includeJdkHeaders() ? ForTestCompileJdkHeaders.jdkHeadersForTests() : null, + compilerSpecialMode.includeKotlinRuntime() ? ForTestCompileRuntime.runtimeJarForTests() : null); + } } diff --git a/compiler/tests/org/jetbrains/jet/JetLiteFixture.java b/compiler/tests/org/jetbrains/jet/JetLiteFixture.java index d0dcf1fa461..f78a35d7984 100644 --- a/compiler/tests/org/jetbrains/jet/JetLiteFixture.java +++ b/compiler/tests/org/jetbrains/jet/JetLiteFixture.java @@ -33,6 +33,7 @@ import org.jetbrains.annotations.NonNls; import org.jetbrains.jet.compiler.CompileEnvironment; import org.jetbrains.jet.compiler.JetCoreEnvironment; import org.jetbrains.jet.lang.psi.JetFile; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import org.jetbrains.jet.plugin.JetLanguage; import java.io.File; @@ -74,7 +75,8 @@ public abstract class JetLiteFixture extends UsefulTestCase { } protected void createEnvironmentWithFullJdk() { - myEnvironment = new JetCoreEnvironment(getTestRootDisposable(), true); + myEnvironment = new JetCoreEnvironment(getTestRootDisposable(), + CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR)); final File rtJar = CompileEnvironment.findRtJar(); myEnvironment.addToClasspath(rtJar); } diff --git a/compiler/tests/org/jetbrains/jet/JetTestUtils.java b/compiler/tests/org/jetbrains/jet/JetTestUtils.java index 126d3e6f199..aa5eae1781f 100644 --- a/compiler/tests/org/jetbrains/jet/JetTestUtils.java +++ b/compiler/tests/org/jetbrains/jet/JetTestUtils.java @@ -33,6 +33,7 @@ import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.java.AnalyzeExhaust; import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import org.jetbrains.jet.util.slicedmap.ReadOnlySlice; import org.jetbrains.jet.util.slicedmap.SlicedMap; import org.jetbrains.jet.util.slicedmap.WritableSlice; @@ -158,12 +159,13 @@ public class JetTestUtils { }; public static AnalyzeExhaust analyzeFile(@NotNull JetFile namespace, @NotNull JetControlFlowDataTraceFactory flowDataTraceFactory) { - return AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(namespace, flowDataTraceFactory); + return AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(namespace, flowDataTraceFactory, + CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR)); } public static JetCoreEnvironment createEnvironmentWithMockJdk(Disposable disposable) { - JetCoreEnvironment environment = new JetCoreEnvironment(disposable, true); + JetCoreEnvironment environment = new JetCoreEnvironment(disposable, CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR)); final File rtJar = new File(JetTestCaseBuilder.getHomeDirectory(), "compiler/testData/mockJDK-1.7/jre/lib/rt.jar"); environment.addToClasspath(rtJar); environment.addToClasspath(getAnnotationsJar()); diff --git a/compiler/tests/org/jetbrains/jet/checkers/CheckerTestUtilTest.java b/compiler/tests/org/jetbrains/jet/checkers/CheckerTestUtilTest.java index 4bd2d3cc75a..875c4c69bac 100644 --- a/compiler/tests/org/jetbrains/jet/checkers/CheckerTestUtilTest.java +++ b/compiler/tests/org/jetbrains/jet/checkers/CheckerTestUtilTest.java @@ -19,12 +19,14 @@ package org.jetbrains.jet.checkers; import com.google.common.collect.Lists; import com.intellij.psi.PsiFile; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.CompileCompilerDependenciesTest; import org.jetbrains.jet.JetLiteFixture; import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; import org.jetbrains.jet.lang.diagnostics.Diagnostic; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import java.util.Collections; import java.util.List; @@ -98,8 +100,8 @@ public class CheckerTestUtilTest extends JetLiteFixture { public void test(final @NotNull PsiFile psiFile) { BindingContext bindingContext = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration( - (JetFile) psiFile, - JetControlFlowDataTraceFactory.EMPTY) + (JetFile) psiFile, JetControlFlowDataTraceFactory.EMPTY, + CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR)) .getBindingContext(); String expectedText = CheckerTestUtil.addDiagnosticMarkersToText(psiFile, CheckerTestUtil.getDiagnosticsIncludingSyntaxErrors(bindingContext, psiFile)).toString(); diff --git a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTest.java b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTest.java index 6c505aca5a7..84a6cf27dac 100644 --- a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTest.java +++ b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTest.java @@ -27,10 +27,10 @@ import com.intellij.psi.PsiFileFactory; import junit.framework.Test; import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.CompileCompilerDependenciesTest; import org.jetbrains.jet.JetLiteFixture; import org.jetbrains.jet.JetTestCaseBuilder; import org.jetbrains.jet.JetTestUtils; -import org.jetbrains.jet.lang.ModuleConfiguration; import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils; import org.jetbrains.jet.lang.psi.JetFile; @@ -167,7 +167,8 @@ public class JetDiagnosticsTest extends JetLiteFixture { } BindingContext bindingContext = AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration( - getProject(), jetFiles, Predicates.alwaysTrue(), JetControlFlowDataTraceFactory.EMPTY, CompilerSpecialMode.REGULAR) + getProject(), jetFiles, Predicates.alwaysTrue(), JetControlFlowDataTraceFactory.EMPTY, + CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR)) .getBindingContext(); boolean ok = true; diff --git a/compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java b/compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java index ed18d54693e..b76603539b7 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java +++ b/compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java @@ -18,6 +18,7 @@ package org.jetbrains.jet.codegen; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.CompileCompilerDependenciesTest; import org.jetbrains.jet.JetLiteFixture; import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; import org.jetbrains.jet.lang.psi.JetFile; @@ -25,6 +26,7 @@ import org.jetbrains.jet.lang.psi.JetPsiUtil; import org.jetbrains.jet.lang.resolve.AnalyzingUtils; import org.jetbrains.jet.lang.resolve.java.AnalyzeExhaust; import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import org.jetbrains.jet.parsing.JetParsingTest; import java.io.IOException; @@ -124,7 +126,9 @@ public abstract class CodegenTestCase extends JetLiteFixture { } private GenerationState generateCommon(ClassBuilderFactory classBuilderFactory) { - final AnalyzeExhaust analyzeExhaust = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegrationAndCheckForErrors(myFile, JetControlFlowDataTraceFactory.EMPTY); + final AnalyzeExhaust analyzeExhaust = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegrationAndCheckForErrors( + myFile, JetControlFlowDataTraceFactory.EMPTY, + CompilerSpecialMode.REGULAR, CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR)); GenerationState state = new GenerationState(getProject(), classBuilderFactory, analyzeExhaust, Collections.singletonList(myFile)); state.compileCorrectFiles(CompilationErrorHandler.THROW_EXCEPTION); return state; diff --git a/compiler/tests/org/jetbrains/jet/codegen/CompileTextTest.java b/compiler/tests/org/jetbrains/jet/codegen/CompileTextTest.java index 3c9e142fccf..3b5b6174c71 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/CompileTextTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/CompileTextTest.java @@ -16,7 +16,9 @@ package org.jetbrains.jet.codegen; +import org.jetbrains.jet.CompileCompilerDependenciesTest; import org.jetbrains.jet.compiler.CompileEnvironment; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; @@ -24,7 +26,7 @@ import java.lang.reflect.Method; public class CompileTextTest extends CodegenTestCase { public void testMe() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException { String text = "import org.jetbrains.jet.codegen.CompileTextTest; fun x() = CompileTextTest()"; - CompileEnvironment compileEnvironment = new CompileEnvironment(); + CompileEnvironment compileEnvironment = new CompileEnvironment(CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR)); compileEnvironment.getEnvironment().addToClasspathFromClassLoader(getClass().getClassLoader()); ClassLoader classLoader = compileEnvironment.compileText(text); Class namespace = classLoader.loadClass("namespace"); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/GenerationUtils.java b/compiler/tests/org/jetbrains/jet/codegen/GenerationUtils.java similarity index 71% rename from compiler/backend/src/org/jetbrains/jet/codegen/GenerationUtils.java rename to compiler/tests/org/jetbrains/jet/codegen/GenerationUtils.java index 22dd565a94e..d5e3ff9cefb 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/GenerationUtils.java +++ b/compiler/tests/org/jetbrains/jet/codegen/GenerationUtils.java @@ -17,10 +17,12 @@ package org.jetbrains.jet.codegen; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.CompileCompilerDependenciesTest; import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.java.AnalyzeExhaust; import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import java.util.Collections; @@ -29,12 +31,14 @@ import java.util.Collections; */ public class GenerationUtils { - public static ClassFileFactory compileFileGetClassFileFactory(@NotNull JetFile psiFile) { - return compileFileGetGenerationState(psiFile).getFactory(); + public static ClassFileFactory compileFileGetClassFileFactoryForTest(@NotNull JetFile psiFile) { + return compileFileGetGenerationStateForTest(psiFile).getFactory(); } - public static GenerationState compileFileGetGenerationState(JetFile psiFile) { - final AnalyzeExhaust analyzeExhaust = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegrationAndCheckForErrors(psiFile, JetControlFlowDataTraceFactory.EMPTY); + public static GenerationState compileFileGetGenerationStateForTest(JetFile psiFile) { + final AnalyzeExhaust analyzeExhaust = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegrationAndCheckForErrors( + psiFile, JetControlFlowDataTraceFactory.EMPTY, + CompilerSpecialMode.REGULAR, CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR)); GenerationState state = new GenerationState(psiFile.getProject(), ClassBuilderFactories.binaries(false), analyzeExhaust, Collections.singletonList(psiFile)); state.compileCorrectFiles(CompilationErrorHandler.THROW_EXCEPTION); return state; diff --git a/compiler/tests/org/jetbrains/jet/codegen/StdlibTest.java b/compiler/tests/org/jetbrains/jet/codegen/StdlibTest.java index 390b757ad79..20f6a1892d4 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/StdlibTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/StdlibTest.java @@ -46,7 +46,6 @@ public class StdlibTest extends CodegenTestCase { } myEnvironment.addToClasspath(junitJar); - CompileEnvironment.ensureRuntime(myEnvironment); } @Override diff --git a/compiler/tests/org/jetbrains/jet/codegen/TestlibTest.java b/compiler/tests/org/jetbrains/jet/codegen/TestlibTest.java index 698d6adf2da..16b6a314a87 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/TestlibTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/TestlibTest.java @@ -21,6 +21,7 @@ import gnu.trove.THashSet; import junit.framework.Test; import junit.framework.TestCase; import junit.framework.TestSuite; +import org.jetbrains.jet.CompileCompilerDependenciesTest; import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileRuntime; import org.jetbrains.jet.compiler.CompileSession; import org.jetbrains.jet.compiler.MessageRenderer; @@ -30,6 +31,7 @@ import org.jetbrains.jet.lang.psi.JetDeclaration; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.DescriptorUtils; +import org.jetbrains.jet.lang.resolve.java.CompilerDependencies; import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.parsing.JetParsingTest; @@ -72,9 +74,9 @@ public class TestlibTest extends CodegenTestCase { private TestSuite doBuildSuite() { try { - CompileSession session = new CompileSession(myEnvironment, MessageRenderer.PLAIN, System.err, false, CompilerSpecialMode.REGULAR); - - myEnvironment.addToClasspath(ForTestCompileRuntime.runtimeJarForTests()); + CompilerDependencies compilerDependencies = CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR); + CompileSession session = new CompileSession(myEnvironment, MessageRenderer.PLAIN, System.err, false, + compilerDependencies); File junitJar = new File("libraries/lib/junit-4.9.jar"); @@ -84,6 +86,8 @@ public class TestlibTest extends CodegenTestCase { myEnvironment.addToClasspath(junitJar); + myEnvironment.addToClasspath(compilerDependencies.getRuntimeJar()); + CoreLocalFileSystem localFileSystem = myEnvironment.getLocalFileSystem(); session.addSources(localFileSystem.findFileByPath(JetParsingTest.getTestDataDir() + "/../../libraries/stdlib/test")); session.addSources(localFileSystem.findFileByPath(JetParsingTest.getTestDataDir() + "/../../libraries/kunit/src")); diff --git a/compiler/tests/org/jetbrains/jet/compiler/CompileEnvironmentTest.java b/compiler/tests/org/jetbrains/jet/compiler/CompileEnvironmentTest.java index 106e1a60d31..11895e7c662 100644 --- a/compiler/tests/org/jetbrains/jet/compiler/CompileEnvironmentTest.java +++ b/compiler/tests/org/jetbrains/jet/compiler/CompileEnvironmentTest.java @@ -18,8 +18,11 @@ package org.jetbrains.jet.compiler; import com.intellij.openapi.util.io.FileUtil; import junit.framework.TestCase; +import org.jetbrains.jet.CompileCompilerDependenciesTest; import org.jetbrains.jet.cli.KotlinCompiler; +import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileJdkHeaders; import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileRuntime; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import org.jetbrains.jet.parsing.JetParsingTest; import org.junit.Assert; @@ -42,10 +45,13 @@ public class CompileEnvironmentTest extends TestCase { try { File stdlib = ForTestCompileRuntime.runtimeJarForTests(); + File jdkHeaders = ForTestCompileJdkHeaders.jdkHeadersForTests(); File resultJar = new File(tempDir, "result.jar"); - KotlinCompiler.ExitCode rv = new KotlinCompiler().exec("-module", JetParsingTest.getTestDataDir() + "/compiler/smoke/Smoke.kts", - "-jar", resultJar.getAbsolutePath(), - "-stdlib", stdlib.getAbsolutePath()); + KotlinCompiler.ExitCode rv = new KotlinCompiler().exec( + "-module", JetParsingTest.getTestDataDir() + "/compiler/smoke/Smoke.kts", + "-jar", resultJar.getAbsolutePath(), + "-stdlib", stdlib.getAbsolutePath(), + "-jdkHeaders", jdkHeaders.getAbsolutePath()); Assert.assertEquals("compilation completed with non-zero code", KotlinCompiler.ExitCode.OK, rv); FileInputStream fileInputStream = new FileInputStream(resultJar); try { @@ -73,9 +79,12 @@ public class CompileEnvironmentTest extends TestCase { try { File out = new File(tempDir, "out"); File stdlib = ForTestCompileRuntime.runtimeJarForTests(); - KotlinCompiler.ExitCode exitCode = new KotlinCompiler().exec("-src", JetParsingTest.getTestDataDir() + "/compiler/smoke/Smoke.kt", - "-output", out.getAbsolutePath(), - "-stdlib", stdlib.getAbsolutePath()); + File jdkHeaders = ForTestCompileJdkHeaders.jdkHeadersForTests(); + KotlinCompiler.ExitCode exitCode = new KotlinCompiler().exec( + "-src", JetParsingTest.getTestDataDir() + "/compiler/smoke/Smoke.kt", + "-output", out.getAbsolutePath(), + "-stdlib", stdlib.getAbsolutePath(), + "-jdkHeaders", jdkHeaders.getAbsolutePath()); Assert.assertEquals(KotlinCompiler.ExitCode.OK, exitCode); assertEquals(1, out.listFiles().length); assertEquals(1, out.listFiles()[0].listFiles().length); diff --git a/compiler/tests/org/jetbrains/jet/compiler/CompileJavaAgainstKotlinTest.java b/compiler/tests/org/jetbrains/jet/compiler/CompileJavaAgainstKotlinTest.java index 63320562d12..1f6b58ae7c8 100644 --- a/compiler/tests/org/jetbrains/jet/compiler/CompileJavaAgainstKotlinTest.java +++ b/compiler/tests/org/jetbrains/jet/compiler/CompileJavaAgainstKotlinTest.java @@ -75,7 +75,7 @@ public class CompileJavaAgainstKotlinTest extends TestCaseWithTmpdir { virtualFile.setCharset(CharsetToolkit.UTF8_CHARSET); JetFile psiFile = (JetFile) ((PsiFileFactoryImpl) PsiFileFactory.getInstance(jetCoreEnvironment.getProject())).trySetupPsiForFile(virtualFile, JetLanguage.INSTANCE, true, false); - ClassFileFactory classFileFactory = GenerationUtils.compileFileGetClassFileFactory(psiFile); + ClassFileFactory classFileFactory = GenerationUtils.compileFileGetClassFileFactoryForTest(psiFile); CompileEnvironment.writeToOutputDirectory(classFileFactory, tmpdir.getPath()); diff --git a/compiler/tests/org/jetbrains/jet/compiler/CompileKotlinAgainstKotlinTest.java b/compiler/tests/org/jetbrains/jet/compiler/CompileKotlinAgainstKotlinTest.java index 55b328a3f76..5f34c489acc 100644 --- a/compiler/tests/org/jetbrains/jet/compiler/CompileKotlinAgainstKotlinTest.java +++ b/compiler/tests/org/jetbrains/jet/compiler/CompileKotlinAgainstKotlinTest.java @@ -89,7 +89,7 @@ public class CompileKotlinAgainstKotlinTest extends TestCaseWithTmpdir { virtualFile.setCharset(CharsetToolkit.UTF8_CHARSET); JetFile psiFile = (JetFile) ((PsiFileFactoryImpl) PsiFileFactory.getInstance(jetCoreEnvironment.getProject())).trySetupPsiForFile(virtualFile, JetLanguage.INSTANCE, true, false); - ClassFileFactory classFileFactory = GenerationUtils.compileFileGetClassFileFactory(psiFile); + ClassFileFactory classFileFactory = GenerationUtils.compileFileGetClassFileFactoryForTest(psiFile); CompileEnvironment.writeToOutputDirectory(classFileFactory, aDir.getPath()); @@ -107,7 +107,7 @@ public class CompileKotlinAgainstKotlinTest extends TestCaseWithTmpdir { virtualFile.setCharset(CharsetToolkit.UTF8_CHARSET); JetFile psiFile = (JetFile) ((PsiFileFactoryImpl) PsiFileFactory.getInstance(jetCoreEnvironment.getProject())).trySetupPsiForFile(virtualFile, JetLanguage.INSTANCE, true, false); - ClassFileFactory classFileFactory = GenerationUtils.compileFileGetClassFileFactory(psiFile); + ClassFileFactory classFileFactory = GenerationUtils.compileFileGetClassFileFactoryForTest(psiFile); CompileEnvironment.writeToOutputDirectory(classFileFactory, bDir.getPath()); diff --git a/compiler/tests/org/jetbrains/jet/compiler/ReadJavaBinaryClassTest.java b/compiler/tests/org/jetbrains/jet/compiler/ReadJavaBinaryClassTest.java index 56348276a12..dca2ff3d43f 100644 --- a/compiler/tests/org/jetbrains/jet/compiler/ReadJavaBinaryClassTest.java +++ b/compiler/tests/org/jetbrains/jet/compiler/ReadJavaBinaryClassTest.java @@ -23,6 +23,7 @@ import com.intellij.psi.impl.PsiFileFactoryImpl; import com.intellij.testFramework.LightVirtualFile; import junit.framework.Test; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.CompileCompilerDependenciesTest; import org.jetbrains.jet.JetTestCaseBuilder; import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.di.InjectorForJavaSemanticServices; @@ -34,6 +35,7 @@ import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingTraceContext; import org.jetbrains.jet.lang.resolve.FqName; import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices; @@ -86,7 +88,8 @@ public class ReadJavaBinaryClassTest extends TestCaseWithTmpdir { JetFile psiFile = (JetFile) ((PsiFileFactoryImpl) PsiFileFactory.getInstance(jetCoreEnvironment.getProject())).trySetupPsiForFile(virtualFile, JetLanguage.INSTANCE, true, false); BindingContext bindingContext = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegrationAndCheckForErrors( - psiFile, JetControlFlowDataTraceFactory.EMPTY) + psiFile, JetControlFlowDataTraceFactory.EMPTY, + CompilerSpecialMode.REGULAR, CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR)) .getBindingContext(); return bindingContext.get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, FqName.topLevel("test")); } @@ -113,7 +116,9 @@ public class ReadJavaBinaryClassTest extends TestCaseWithTmpdir { jetCoreEnvironment.addToClasspath(tmpdir); jetCoreEnvironment.addToClasspath(new File("out/production/runtime")); - JavaDescriptorResolver javaDescriptorResolver = new InjectorForJavaSemanticServices(jetCoreEnvironment.getProject()).getJavaDescriptorResolver(); + InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices( + CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR), jetCoreEnvironment.getProject()); + JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver(); return javaDescriptorResolver.resolveNamespace(FqName.topLevel("test"), DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN); } diff --git a/compiler/tests/org/jetbrains/jet/compiler/ReadKotlinBinaryClassTest.java b/compiler/tests/org/jetbrains/jet/compiler/ReadKotlinBinaryClassTest.java index 96924319dfc..def2436d1e1 100644 --- a/compiler/tests/org/jetbrains/jet/compiler/ReadKotlinBinaryClassTest.java +++ b/compiler/tests/org/jetbrains/jet/compiler/ReadKotlinBinaryClassTest.java @@ -25,6 +25,7 @@ import com.intellij.testFramework.LightVirtualFile; import junit.framework.Assert; import junit.framework.Test; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.CompileCompilerDependenciesTest; import org.jetbrains.jet.JetTestCaseBuilder; import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.codegen.ClassFileFactory; @@ -35,6 +36,7 @@ import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.FqName; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.plugin.JetLanguage; @@ -69,7 +71,7 @@ public class ReadKotlinBinaryClassTest extends TestCaseWithTmpdir { virtualFile.setCharset(CharsetToolkit.UTF8_CHARSET); JetFile psiFile = (JetFile) ((PsiFileFactoryImpl) PsiFileFactory.getInstance(jetCoreEnvironment.getProject())).trySetupPsiForFile(virtualFile, JetLanguage.INSTANCE, true, false); - GenerationState state = GenerationUtils.compileFileGetGenerationState(psiFile); + GenerationState state = GenerationUtils.compileFileGetGenerationStateForTest(psiFile); ClassFileFactory classFileFactory = state.getFactory(); @@ -87,7 +89,9 @@ public class ReadKotlinBinaryClassTest extends TestCaseWithTmpdir { jetCoreEnvironment.addToClasspath(tmpdir); jetCoreEnvironment.addToClasspath(new File("out/production/runtime")); - JavaDescriptorResolver javaDescriptorResolver = new InjectorForJavaSemanticServices(jetCoreEnvironment.getProject()).getJavaDescriptorResolver(); + InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices( + CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR), jetCoreEnvironment.getProject()); + JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver(); NamespaceDescriptor namespaceFromClass = javaDescriptorResolver.resolveNamespace(FqName.topLevel("test"), DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN); NamespaceComparator.compareNamespaces(namespaceFromSource, namespaceFromClass, false, txtFile); diff --git a/compiler/tests/org/jetbrains/jet/compiler/WriteSignatureTest.java b/compiler/tests/org/jetbrains/jet/compiler/WriteSignatureTest.java index 8f7e046d392..71c3ad1298f 100644 --- a/compiler/tests/org/jetbrains/jet/compiler/WriteSignatureTest.java +++ b/compiler/tests/org/jetbrains/jet/compiler/WriteSignatureTest.java @@ -80,7 +80,7 @@ public class WriteSignatureTest extends TestCaseWithTmpdir { virtualFile.setCharset(CharsetToolkit.UTF8_CHARSET); JetFile psiFile = (JetFile) ((PsiFileFactoryImpl) PsiFileFactory.getInstance(jetCoreEnvironment.getProject())).trySetupPsiForFile(virtualFile, JetLanguage.INSTANCE, true, false); - ClassFileFactory classFileFactory = GenerationUtils.compileFileGetClassFileFactory(psiFile); + ClassFileFactory classFileFactory = GenerationUtils.compileFileGetClassFileFactoryForTest(psiFile); CompileEnvironment.writeToOutputDirectory(classFileFactory, tmpdir.getPath()); diff --git a/compiler/tests/org/jetbrains/jet/resolve/DescriptorRendererTest.java b/compiler/tests/org/jetbrains/jet/resolve/DescriptorRendererTest.java index 083e570bc9a..b1ac36e985f 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/DescriptorRendererTest.java +++ b/compiler/tests/org/jetbrains/jet/resolve/DescriptorRendererTest.java @@ -18,6 +18,7 @@ package org.jetbrains.jet.resolve; import com.intellij.openapi.editor.Document; import com.intellij.openapi.editor.impl.DocumentImpl; +import org.jetbrains.jet.CompileCompilerDependenciesTest; import org.jetbrains.jet.JetLiteFixture; import org.jetbrains.jet.JetTestCaseBuilder; import org.jetbrains.jet.JetTestUtils; @@ -29,6 +30,7 @@ import org.jetbrains.jet.lang.psi.JetVisitorVoid; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.java.AnalyzeExhaust; import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import java.io.IOException; import java.util.ArrayList; @@ -68,7 +70,9 @@ public class DescriptorRendererTest extends JetLiteFixture { String fileName = getTestName(false) + ".kt"; JetFile psiFile = createPsiFile(fileName, loadFile(fileName)); AnalyzeExhaust analyzeExhaust = - AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration((JetFile)psiFile, JetControlFlowDataTraceFactory.EMPTY); + AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration( + (JetFile) psiFile, JetControlFlowDataTraceFactory.EMPTY, + CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR)); final BindingContext bindingContext = analyzeExhaust.getBindingContext(); final List descriptors = new ArrayList(); psiFile.acceptChildren(new JetVisitorVoid() { diff --git a/compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java b/compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java index 862ea23cc5b..b7766e30d8f 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java +++ b/compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java @@ -23,6 +23,7 @@ import com.intellij.openapi.project.Project; import com.intellij.psi.PsiElement; import com.intellij.psi.PsiFile; import com.intellij.psi.util.PsiTreeUtil; +import org.jetbrains.jet.CompileCompilerDependenciesTest; import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.diagnostics.Diagnostic; @@ -139,7 +140,8 @@ public abstract class ExpectedResolveData { JetStandardLibrary lib = JetStandardLibrary.getInstance(); AnalyzeExhaust analyzeExhaust = AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(project, files, - Predicates.alwaysTrue(), JetControlFlowDataTraceFactory.EMPTY, CompilerSpecialMode.REGULAR); + Predicates.alwaysTrue(), JetControlFlowDataTraceFactory.EMPTY, + CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR)); BindingContext bindingContext = analyzeExhaust.getBindingContext(); for (Diagnostic diagnostic : bindingContext.getDiagnostics()) { if (diagnostic instanceof UnresolvedReferenceDiagnostic) { diff --git a/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java b/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java index bd62dc67e58..5f28eafec9d 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java +++ b/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java @@ -24,6 +24,7 @@ import com.intellij.psi.PsiElement; import com.intellij.psi.PsiMethod; import junit.framework.Test; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.CompileCompilerDependenciesTest; import org.jetbrains.jet.JetTestCaseBuilder; import org.jetbrains.jet.di.InjectorForJavaSemanticServices; import org.jetbrains.jet.di.InjectorForTests; @@ -36,6 +37,7 @@ import org.jetbrains.jet.lang.resolve.FqName; import org.jetbrains.jet.lang.resolve.calls.CallResolver; import org.jetbrains.jet.lang.resolve.calls.OverloadResolutionResults; import org.jetbrains.jet.lang.resolve.calls.ResolvedCall; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; import org.jetbrains.jet.lang.types.JetType; @@ -123,7 +125,8 @@ public class JetResolveTest extends ExtensibleResolveTestCase { @NotNull private PsiClass findClass(String qualifiedName) { Project project = getProject(); - InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices(project); + InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices( + CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR), project); return injector.getPsiClassFinderForJvm().findPsiClass(new FqName(qualifiedName)); } diff --git a/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java b/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java index 3d8a6fe4d30..c38cc9db853 100644 --- a/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java +++ b/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java @@ -16,6 +16,7 @@ package org.jetbrains.jet.types; +import org.jetbrains.jet.CompileCompilerDependenciesTest; import org.jetbrains.jet.JetLiteFixture; import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.di.InjectorForTests; @@ -25,6 +26,7 @@ import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.DescriptorResolver; import org.jetbrains.jet.lang.resolve.java.AnalyzeExhaust; import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; @@ -62,7 +64,9 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture { List declarations = file.getDeclarations(); JetDeclaration aClass = declarations.get(0); assert aClass instanceof JetClass; - AnalyzeExhaust bindingContext = AnalyzerFacadeForJVM.analyzeFileWithCache(file, AnalyzerFacadeForJVM.SINGLE_DECLARATION_PROVIDER); + AnalyzeExhaust bindingContext = AnalyzerFacadeForJVM.analyzeFileWithCache( + file, AnalyzerFacadeForJVM.SINGLE_DECLARATION_PROVIDER, + CompilerSpecialMode.REGULAR, CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR)); DeclarationDescriptor classDescriptor = bindingContext.getBindingContext().get(BindingContext.DECLARATION_TO_DESCRIPTOR, aClass); WritableScopeImpl scope = new WritableScopeImpl(libraryScope, root, RedeclarationHandler.DO_NOTHING); assert classDescriptor instanceof ClassifierDescriptor; diff --git a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java index 671c8dbb6f9..b472a490c30 100644 --- a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java +++ b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java @@ -20,6 +20,7 @@ import com.google.common.collect.Sets; import com.intellij.openapi.project.Project; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.CompileCompilerDependenciesTest; import org.jetbrains.jet.JetLiteFixture; import org.jetbrains.jet.JetTestCaseBuilder; import org.jetbrains.jet.JetTestUtils; @@ -585,7 +586,9 @@ public class JetTypeCheckerTest extends JetLiteFixture { private WritableScopeImpl addImports(JetScope scope) { WritableScopeImpl writableScope = new WritableScopeImpl(scope, scope.getContainingDeclaration(), RedeclarationHandler.DO_NOTHING); writableScope.importScope(library.getLibraryScope()); - JavaDescriptorResolver javaDescriptorResolver = new InjectorForJavaSemanticServices(getProject()).getJavaDescriptorResolver(); + InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices( + CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR), getProject()); + JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver(); writableScope.importScope(javaDescriptorResolver.resolveNamespace(FqName.ROOT, DescriptorSearchRule.INCLUDE_KOTLIN).getMemberScope()); writableScope.importScope(javaDescriptorResolver.resolveNamespace(new FqName("java.lang"), diff --git a/compiler/util/src/org/jetbrains/jet/utils/PathUtil.java b/compiler/util/src/org/jetbrains/jet/utils/PathUtil.java index 01e5077daff..362ba0374e4 100644 --- a/compiler/util/src/org/jetbrains/jet/utils/PathUtil.java +++ b/compiler/util/src/org/jetbrains/jet/utils/PathUtil.java @@ -77,7 +77,7 @@ public class PathUtil { File compilerPath = getDefaultCompilerPath(); if (compilerPath == null) return null; - File answer = new File(compilerPath, "lib/alt"); + File answer = new File(compilerPath, "lib/alt/kotlin-jdk-headers.jar"); return answer.exists() ? answer : null; } @@ -94,10 +94,18 @@ public class PathUtil { if (alts != null) { for (File root : alts.listFiles()) { - VirtualFile jarRoot = VirtualFileManager.getInstance().findFileByUrl("jar://" + root.getPath() + "!/"); + VirtualFile jarRoot = jarFileToVirtualFile(root); roots.add(jarRoot); } } return roots; } + + @NotNull + public static VirtualFile jarFileToVirtualFile(@NotNull File file) { + if (!file.exists() || !file.isFile()) { + throw new IllegalStateException("file must exist and be regular to be converted to virtual file: " + file); + } + return VirtualFileManager.getInstance().findFileByUrl("jar://" + file.getPath() + "!/"); + } } diff --git a/idea/src/org/jetbrains/jet/plugin/libraries/DecompiledDataFactory.java b/idea/src/org/jetbrains/jet/plugin/libraries/DecompiledDataFactory.java index 1e8de9e48b2..0b9022eb504 100644 --- a/idea/src/org/jetbrains/jet/plugin/libraries/DecompiledDataFactory.java +++ b/idea/src/org/jetbrains/jet/plugin/libraries/DecompiledDataFactory.java @@ -32,6 +32,8 @@ import org.jetbrains.jet.lang.psi.JetDeclaration; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.FqName; +import org.jetbrains.jet.lang.resolve.java.CompilerDependencies; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.JvmAbi; @@ -59,7 +61,8 @@ class DecompiledDataFactory { private DecompiledDataFactory(ClsFileImpl clsFile) { myClsFile = clsFile; Project project = myClsFile.getProject(); - InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices(project); + InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices( + CompilerDependencies.compilerDependenciesForProduction(CompilerSpecialMode.REGULAR), project); myBindingContext = injector.getBindingTrace().getBindingContext(); myJavaDescriptorResolver = injector.getJavaDescriptorResolver(); } diff --git a/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java b/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java index fad79da6c0b..791f6a60c89 100644 --- a/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java +++ b/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java @@ -39,6 +39,7 @@ import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.FqName; import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; +import org.jetbrains.jet.lang.resolve.java.CompilerDependencies; import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; @@ -74,7 +75,7 @@ public class JetSourceNavigationHelper { libraryFiles, Predicates.alwaysTrue(), JetControlFlowDataTraceFactory.EMPTY, - CompilerSpecialMode.REGULAR).getBindingContext(); + CompilerDependencies.compilerDependenciesForProduction(CompilerSpecialMode.REGULAR)).getBindingContext(); D descriptor = bindingContext.get(slice, fqName); if (descriptor != null) { return new Tuple2(bindingContext, descriptor); diff --git a/idea/src/org/jetbrains/jet/plugin/parameterInfo/JetFunctionParameterInfoHandler.java b/idea/src/org/jetbrains/jet/plugin/parameterInfo/JetFunctionParameterInfoHandler.java index 04896e14f59..55599a04cb2 100644 --- a/idea/src/org/jetbrains/jet/plugin/parameterInfo/JetFunctionParameterInfoHandler.java +++ b/idea/src/org/jetbrains/jet/plugin/parameterInfo/JetFunctionParameterInfoHandler.java @@ -32,6 +32,8 @@ import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.JetVisibilityChecker; import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; +import org.jetbrains.jet.lang.resolve.java.CompilerDependencies; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.checker.JetTypeChecker; @@ -190,7 +192,8 @@ public class JetFunctionParameterInfoHandler implements if (descriptor instanceof FunctionDescriptor) { JetFile file = (JetFile) argumentList.getContainingFile(); BindingContext bindingContext = - AnalyzerFacadeForJVM.analyzeFileWithCache(file, AnalyzerFacadeForJVM.SINGLE_DECLARATION_PROVIDER) + AnalyzerFacadeForJVM.analyzeFileWithCache(file, AnalyzerFacadeForJVM.SINGLE_DECLARATION_PROVIDER, + CompilerSpecialMode.REGULAR, CompilerDependencies.compilerDependenciesForProduction(CompilerSpecialMode.REGULAR)) .getBindingContext(); FunctionDescriptor functionDescriptor = (FunctionDescriptor) descriptor; StringBuilder builder = new StringBuilder(); @@ -331,7 +334,7 @@ public class JetFunctionParameterInfoHandler implements } else return null; BindingContext bindingContext = AnalyzerFacadeForJVM.analyzeFileWithCache( (JetFile) file, - AnalyzerFacadeForJVM.SINGLE_DECLARATION_PROVIDER) + AnalyzerFacadeForJVM.SINGLE_DECLARATION_PROVIDER, CompilerSpecialMode.REGULAR, CompilerDependencies.compilerDependenciesForProduction(CompilerSpecialMode.REGULAR)) .getBindingContext(); JetExpression calleeExpression = callExpression.getCalleeExpression(); if (calleeExpression == null) return null; diff --git a/idea/src/org/jetbrains/jet/plugin/project/WholeProjectAnalyzerFacade.java b/idea/src/org/jetbrains/jet/plugin/project/WholeProjectAnalyzerFacade.java index 1fb82439458..5e3d3a27b42 100644 --- a/idea/src/org/jetbrains/jet/plugin/project/WholeProjectAnalyzerFacade.java +++ b/idea/src/org/jetbrains/jet/plugin/project/WholeProjectAnalyzerFacade.java @@ -22,6 +22,8 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.java.AnalyzeExhaust; import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; +import org.jetbrains.jet.lang.resolve.java.CompilerDependencies; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import org.jetbrains.jet.lang.resolve.java.JetFilesProvider; /** @@ -35,11 +37,13 @@ public final class WholeProjectAnalyzerFacade { @NotNull public static AnalyzeExhaust analyzeProjectWithCacheOnAFile(@NotNull JetFile file) { - return AnalyzerFacadeForJVM.analyzeFileWithCache(file, JetFilesProvider.getInstance(file.getProject()).sampleToAllFilesInModule()); + return AnalyzerFacadeForJVM.analyzeFileWithCache(file, JetFilesProvider.getInstance(file.getProject()).sampleToAllFilesInModule(), + CompilerSpecialMode.REGULAR, CompilerDependencies.compilerDependenciesForProduction(CompilerSpecialMode.REGULAR)); } @NotNull public static AnalyzeExhaust analyzeProjectWithCache(@NotNull Project project, @NotNull GlobalSearchScope scope) { - return AnalyzerFacadeForJVM.analyzeProjectWithCache(project, JetFilesProvider.getInstance(project).allInScope(scope)); + return AnalyzerFacadeForJVM.analyzeProjectWithCache(project, JetFilesProvider.getInstance(project).allInScope(scope), + CompilerSpecialMode.REGULAR, CompilerDependencies.compilerDependenciesForProduction(CompilerSpecialMode.REGULAR)); } } diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableMutabilityFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableMutabilityFix.java index 5e95c71da6b..461ec3a29ce 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableMutabilityFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableMutabilityFix.java @@ -32,6 +32,8 @@ import org.jetbrains.jet.lang.psi.JetSimpleNameExpression; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingContextUtils; import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; +import org.jetbrains.jet.lang.resolve.java.CompilerDependencies; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import org.jetbrains.jet.plugin.JetBundle; /** @@ -73,7 +75,9 @@ public class ChangeVariableMutabilityFix implements IntentionAction { if (property != null) return property; JetSimpleNameExpression simpleNameExpression = PsiTreeUtil.getParentOfType(elementAtCaret, JetSimpleNameExpression.class); if (simpleNameExpression != null) { - BindingContext bindingContext = AnalyzerFacadeForJVM.analyzeFileWithCache(file, AnalyzerFacadeForJVM.SINGLE_DECLARATION_PROVIDER) + BindingContext bindingContext = AnalyzerFacadeForJVM.analyzeFileWithCache( + file, AnalyzerFacadeForJVM.SINGLE_DECLARATION_PROVIDER, + CompilerSpecialMode.REGULAR, CompilerDependencies.compilerDependenciesForProduction(CompilerSpecialMode.REGULAR)) .getBindingContext(); VariableDescriptor descriptor = BindingContextUtils.extractVariableDescriptorIfAny(bindingContext, simpleNameExpression, true); if (descriptor != null) { diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVisibilityModifierFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVisibilityModifierFix.java index b058c310a17..ec5b0be44a2 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVisibilityModifierFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVisibilityModifierFix.java @@ -31,6 +31,8 @@ import org.jetbrains.jet.lang.psi.JetParameter; import org.jetbrains.jet.lang.psi.JetPropertyAccessor; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; +import org.jetbrains.jet.lang.resolve.java.CompilerDependencies; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import org.jetbrains.jet.lexer.JetKeywordToken; import org.jetbrains.jet.lexer.JetToken; import org.jetbrains.jet.lexer.JetTokens; @@ -71,7 +73,8 @@ public class ChangeVisibilityModifierFix extends JetIntentionAction result = new ArrayList(); BindingContext bindingContext = AnalyzerFacadeForJVM.analyzeFileWithCache((JetFile) expression.getContainingFile(), - AnalyzerFacadeForJVM.SINGLE_DECLARATION_PROVIDER) + AnalyzerFacadeForJVM.SINGLE_DECLARATION_PROVIDER, + CompilerSpecialMode.REGULAR, CompilerDependencies.compilerDependenciesForProduction(CompilerSpecialMode.REGULAR)) .getBindingContext(); JetType jetType = bindingContext.get(BindingContext.EXPRESSION_TYPE, expression); if (jetType != null) { diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/JetRefactoringUtil.java b/idea/src/org/jetbrains/jet/plugin/refactoring/JetRefactoringUtil.java index ae1352e8b6b..0a3d4e72621 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/JetRefactoringUtil.java +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/JetRefactoringUtil.java @@ -31,6 +31,8 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; +import org.jetbrains.jet.lang.resolve.java.CompilerDependencies; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.NamespaceType; @@ -103,7 +105,8 @@ public class JetRefactoringUtil { if (addExpression) { JetExpression expression = (JetExpression) element; BindingContext bindingContext = AnalyzerFacadeForJVM.analyzeFileWithCache((JetFile) expression.getContainingFile(), - AnalyzerFacadeForJVM.SINGLE_DECLARATION_PROVIDER) + AnalyzerFacadeForJVM.SINGLE_DECLARATION_PROVIDER, CompilerSpecialMode.REGULAR, + CompilerDependencies.compilerDependenciesForProduction(CompilerSpecialMode.REGULAR)) .getBindingContext(); JetType expressionType = bindingContext.get(BindingContext.EXPRESSION_TYPE, expression); if (expressionType == null || !(expressionType instanceof NamespaceType) && diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/introduceVariable/JetIntroduceVariableHandler.java b/idea/src/org/jetbrains/jet/plugin/refactoring/introduceVariable/JetIntroduceVariableHandler.java index 0469eaa0675..5a17d347615 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/introduceVariable/JetIntroduceVariableHandler.java +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/introduceVariable/JetIntroduceVariableHandler.java @@ -38,6 +38,8 @@ import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; +import org.jetbrains.jet.lang.resolve.java.CompilerDependencies; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.NamespaceType; @@ -96,7 +98,7 @@ public class JetIntroduceVariableHandler extends JetIntroduceHandlerBase { } } BindingContext bindingContext = AnalyzerFacadeForJVM.analyzeFileWithCache((JetFile) expression.getContainingFile(), - AnalyzerFacadeForJVM.SINGLE_DECLARATION_PROVIDER) + AnalyzerFacadeForJVM.SINGLE_DECLARATION_PROVIDER, CompilerSpecialMode.REGULAR, CompilerDependencies.compilerDependenciesForProduction(CompilerSpecialMode.REGULAR)) .getBindingContext(); final JetType expressionType = bindingContext.get(BindingContext.EXPRESSION_TYPE, expression); //can be null or error type if (expressionType instanceof NamespaceType) { @@ -350,7 +352,7 @@ public class JetIntroduceVariableHandler extends JetIntroduceHandlerBase { final ArrayList result = new ArrayList(); final BindingContext bindingContext = AnalyzerFacadeForJVM.analyzeFileWithCache((JetFile) expression.getContainingFile(), - AnalyzerFacadeForJVM.SINGLE_DECLARATION_PROVIDER) + AnalyzerFacadeForJVM.SINGLE_DECLARATION_PROVIDER, CompilerSpecialMode.REGULAR, CompilerDependencies.compilerDependenciesForProduction(CompilerSpecialMode.REGULAR)) .getBindingContext(); JetVisitorVoid visitor = new JetVisitorVoid() { diff --git a/injector-generator/src/org/jetbrains/jet/di/AllInjectorsGenerator.java b/injector-generator/src/org/jetbrains/jet/di/AllInjectorsGenerator.java index 7da2a677043..ccf3d1e2420 100644 --- a/injector-generator/src/org/jetbrains/jet/di/AllInjectorsGenerator.java +++ b/injector-generator/src/org/jetbrains/jet/di/AllInjectorsGenerator.java @@ -69,7 +69,8 @@ public class AllInjectorsGenerator { private static void generateInjectorForTopDownAnalyzerForJvm() throws IOException { DependencyInjectorGenerator generator = new DependencyInjectorGenerator(false); generateInjectorForTopDownAnalyzerCommon(generator); - generator.addParameter(CompilerSpecialMode.class); + generator.addParameter(CompilerDependencies.class); + generator.addField(false, CompilerSpecialMode.class, null, new GivenExpression("compilerDependencies.getCompilerSpecialMode()")); generator.addPublicField(JavaBridgeConfiguration.class); generator.addField(PsiClassFinderForJvm.class); generator.generate("compiler/frontend.java/src", "org.jetbrains.jet.di", "InjectorForTopDownAnalyzerForJvm"); @@ -132,7 +133,8 @@ public class AllInjectorsGenerator { generator.addPublicField(PsiClassFinderForJvm.class); generator.addField(false, ModuleDescriptor.class, null, new GivenExpression("new org.jetbrains.jet.lang.descriptors.ModuleDescriptor(\"\")")); - generator.addField(CompilerSpecialMode.REGULAR); + generator.addParameter(CompilerDependencies.class); + generator.addField(false, CompilerSpecialMode.class, null, new GivenExpression("compilerDependencies.getCompilerSpecialMode()")); // Parameters generator.addPublicParameter(Project.class);