@NotNull public static ClassFileFactory generateFiles( @NotNull JetCoreEnvironment environment, @NotNull CodegenTestFiles files) { AnalyzeExhaust analyzeExhaust = AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationAndCheckForErrors( environment.getProject(), files.getPsiFiles(), files.getScriptParameterTypes(), Predicates.<PsiFile>alwaysTrue()); analyzeExhaust.throwIfError(); AnalyzingUtils.throwExceptionOnErrors(analyzeExhaust.getBindingContext()); CompilerConfiguration configuration = environment.getConfiguration(); GenerationState state = new GenerationState( environment.getProject(), ClassBuilderFactories.TEST, Progress.DEAF, analyzeExhaust.getBindingContext(), files.getPsiFiles(), configuration.get(JVMConfigurationKeys.GENERATE_NOT_NULL_ASSERTIONS, true), configuration.get(JVMConfigurationKeys.GENERATE_NOT_NULL_PARAMETER_ASSERTIONS, true), /*generateDeclaredClasses = */ true, configuration.get( JVMConfigurationKeys.ENABLE_INLINE, InlineUtil.DEFAULT_INLINE_FLAG_FOR_TEST)); KotlinCodegenFacade.compileCorrectFiles(state, CompilationErrorHandler.THROW_EXCEPTION); return state.getFactory(); }
public void doTest(String path) throws Exception { File dir = new File(path); CompilerConfiguration configuration = JetTestUtils.compilerConfigurationForTests( ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, new File(dir, "java")); configuration.put( CommonConfigurationKeys.SOURCE_ROOTS_KEY, Arrays.asList(new File(dir, "kotlin").getAbsolutePath())); JetCoreEnvironment environment = new JetCoreEnvironment(getTestRootDisposable(), configuration); ModuleDescriptor moduleDescriptor = new ModuleDescriptor(Name.special("<test module>")); // we need the same binding trace for resolve from Java and Kotlin BindingTrace trace = CliLightClassGenerationSupport.getInstanceForCli(environment.getProject()).getTrace(); InjectorForJavaDescriptorResolver injectorForJava = new InjectorForJavaDescriptorResolver(environment.getProject(), trace, moduleDescriptor); InjectorForTopDownAnalyzerForJvm injectorForAnalyzer = new InjectorForTopDownAnalyzerForJvm( environment.getProject(), new TopDownAnalysisParameters( Predicates.<PsiFile>alwaysFalse(), false, false, Collections.<AnalyzerScriptParameter>emptyList()), trace, moduleDescriptor); injectorForAnalyzer .getTopDownAnalyzer() .analyzeFiles( environment.getSourceFiles(), Collections.<AnalyzerScriptParameter>emptyList()); JavaDescriptorResolver javaDescriptorResolver = injectorForJava.getJavaDescriptorResolver(); NamespaceDescriptor namespaceDescriptor = javaDescriptorResolver.resolveNamespace( LoadDescriptorUtil.TEST_PACKAGE_FQNAME, DescriptorSearchRule.INCLUDE_KOTLIN); assert namespaceDescriptor != null; compareNamespaceWithFile( namespaceDescriptor, NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT, new File(dir, "expected.txt")); ExpectedLoadErrorsUtil.checkForLoadErrors(namespaceDescriptor, trace.getBindingContext()); }
public ReplInterpreter( @NotNull Disposable disposable, @NotNull CompilerConfiguration configuration) { jetCoreEnvironment = JetCoreEnvironment.createForProduction(disposable, configuration); Project project = jetCoreEnvironment.getProject(); trace = new BindingTraceContext(); module = AnalyzerFacadeForJVM.createJavaModule("<repl>"); TopDownAnalysisParameters topDownAnalysisParameters = TopDownAnalysisParameters.createForLocalDeclarations( new LockBasedStorageManager(), new ExceptionTracker(), // dummy Predicates.<PsiFile>alwaysTrue()); injector = new InjectorForTopDownAnalyzerForJvm( project, topDownAnalysisParameters, trace, module, MemberFilter.ALWAYS_TRUE); topDownAnalysisContext = new TopDownAnalysisContext(topDownAnalysisParameters); module.addFragmentProvider(SOURCES, injector.getTopDownAnalyzer().getPackageFragmentProvider()); module.addFragmentProvider( BUILT_INS, KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider()); module.addFragmentProvider( BINARIES, injector.getJavaDescriptorResolver().getPackageFragmentProvider()); List<URL> classpath = Lists.newArrayList(); for (File file : configuration.getList(JVMConfigurationKeys.CLASSPATH_KEY)) { try { classpath.add(file.toURI().toURL()); } catch (MalformedURLException e) { throw UtilsPackage.rethrow(e); } } classLoader = new ReplClassLoader(new URLClassLoader(classpath.toArray(new URL[0]))); }
@NotNull public static NamespaceDescriptor compileJava( @NotNull Collection<File> javaFiles, File tmpdir, Disposable disposable) throws IOException { JavaCompiler javaCompiler = ToolProvider.getSystemJavaCompiler(); StandardJavaFileManager fileManager = javaCompiler.getStandardFileManager(null, Locale.ENGLISH, Charset.forName("utf-8")); try { Iterable<? extends JavaFileObject> javaFileObjectsFromFiles = fileManager.getJavaFileObjectsFromFiles(javaFiles); List<String> options = Arrays.asList( "-classpath", "out/production/runtime" + File.pathSeparator + JetTestUtils.getAnnotationsJar().getPath(), "-d", tmpdir.getPath()); JavaCompiler.CompilationTask task = javaCompiler.getTask(null, fileManager, null, options, null, javaFileObjectsFromFiles); Assert.assertTrue(task.call()); } finally { fileManager.close(); } JetCoreEnvironment jetCoreEnvironment = new JetCoreEnvironment( disposable, CompileCompilerDependenciesTest.compilerConfigurationForTests( ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, JetTestUtils.getAnnotationsJar(), tmpdir, new File("out/production/runtime"))); InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices( BuiltinsScopeExtensionMode.ALL, jetCoreEnvironment.getProject()); JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver(); return javaDescriptorResolver.resolveNamespace( FqName.topLevel(Name.identifier("test")), DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN); }
public void testNoAssertionsForKotlinFromBinary() throws Exception { CompilerConfiguration configuration = JetTestUtils.compilerConfigurationForTests( ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK); JetCoreEnvironment tmpEnvironment = new JetCoreEnvironment(getTestRootDisposable(), configuration); GenerationState state = generateCommon( ClassBuilderFactories.TEST, tmpEnvironment, CodegenTestFiles.create( tmpEnvironment.getProject(), new String[] {"notNullAssertions/noAssertionsForKotlin.kt"})); File compiledDirectory = new File(FileUtil.getTempDirectory(), "kotlin-classes"); CompileEnvironmentUtil.writeToOutputDirectory(state.getFactory(), compiledDirectory); setUpEnvironment(true, false, compiledDirectory); loadFile("notNullAssertions/noAssertionsForKotlinMain.kt"); assertNoIntrinsicsMethodIsCalled(PackageClassUtils.getPackageClassName(FqName.ROOT)); }
@NotNull public LineResult eval(@NotNull String line) { ++lineNumber; FqName scriptFqName = new FqName("Line" + lineNumber); Type scriptClassType = asmTypeByFqNameWithoutInnerClasses(scriptFqName); StringBuilder fullText = new StringBuilder(); for (String prevLine : previousIncompleteLines) { fullText.append(prevLine + "\n"); } fullText.append(line); LightVirtualFile virtualFile = new LightVirtualFile( "line" + lineNumber + JetParserDefinition.STD_SCRIPT_EXT, JetLanguage.INSTANCE, fullText.toString()); virtualFile.setCharset(CharsetToolkit.UTF8_CHARSET); JetFile psiFile = (JetFile) ((PsiFileFactoryImpl) PsiFileFactory.getInstance(jetCoreEnvironment.getProject())) .trySetupPsiForFile(virtualFile, JetLanguage.INSTANCE, true, false); MessageCollectorToString errorCollector = new MessageCollectorToString(); AnalyzerWithCompilerReport.SyntaxErrorReport syntaxErrorReport = AnalyzerWithCompilerReport.reportSyntaxErrors(psiFile, errorCollector); if (syntaxErrorReport.isOnlyErrorAtEof()) { previousIncompleteLines.add(line); return LineResult.incomplete(); } previousIncompleteLines.clear(); if (syntaxErrorReport.isHasErrors()) { return LineResult.error(errorCollector.getString()); } prepareForTheNextReplLine(topDownAnalysisContext); trace.clearDiagnostics(); psiFile.getScript().putUserData(ScriptHeaderResolver.PRIORITY_KEY, lineNumber); ScriptDescriptor scriptDescriptor = doAnalyze(psiFile, errorCollector); if (scriptDescriptor == null) { return LineResult.error(errorCollector.getString()); } List<Pair<ScriptDescriptor, Type>> earlierScripts = Lists.newArrayList(); for (EarlierLine earlierLine : earlierLines) { earlierScripts.add( Pair.create(earlierLine.getScriptDescriptor(), earlierLine.getClassType())); } BindingContext bindingContext = AnalyzeExhaust.success(trace.getBindingContext(), module).getBindingContext(); GenerationState generationState = new GenerationState( psiFile.getProject(), ClassBuilderFactories.BINARIES, bindingContext, Collections.singletonList(psiFile), CompilerArgumentsUtil.DEFAULT_INLINE_FLAG); compileScript( psiFile.getScript(), scriptClassType, earlierScripts, generationState, CompilationErrorHandler.THROW_EXCEPTION); for (OutputFile outputFile : generationState.getFactory().asList()) { classLoader.addClass( JvmClassName.byInternalName(outputFile.getRelativePath().replaceFirst("\\.class$", "")), outputFile.asByteArray()); } try { Class<?> scriptClass = classLoader.loadClass(scriptFqName.asString()); Class<?>[] constructorParams = new Class<?>[earlierLines.size()]; Object[] constructorArgs = new Object[earlierLines.size()]; for (int i = 0; i < earlierLines.size(); ++i) { constructorParams[i] = earlierLines.get(i).getScriptClass(); constructorArgs[i] = earlierLines.get(i).getScriptInstance(); } Constructor<?> scriptInstanceConstructor = scriptClass.getConstructor(constructorParams); Object scriptInstance; try { scriptInstance = scriptInstanceConstructor.newInstance(constructorArgs); } catch (Throwable e) { return LineResult.error(Throwables.getStackTraceAsString(e)); } Field rvField = scriptClass.getDeclaredField("rv"); rvField.setAccessible(true); Object rv = rvField.get(scriptInstance); earlierLines.add( new EarlierLine(line, scriptDescriptor, scriptClass, scriptInstance, scriptClassType)); return LineResult.successful( rv, KotlinBuiltIns.getInstance() .getUnitType() .equals(scriptDescriptor.getScriptCodeDescriptor().getReturnType())); } catch (Throwable e) { PrintWriter writer = new PrintWriter(System.err); classLoader.dumpClasses(writer); writer.flush(); throw UtilsPackage.rethrow(e); } }