diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/GeneratedClassLoader.java b/compiler/backend/src/org/jetbrains/jet/codegen/GeneratedClassLoader.java index 53bd07f28f6..cf95022507d 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/GeneratedClassLoader.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/GeneratedClassLoader.java @@ -17,6 +17,7 @@ package org.jetbrains.jet.codegen; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.OutputFile; import java.net.URL; import java.net.URLClassLoader; @@ -32,11 +33,14 @@ public class GeneratedClassLoader extends URLClassLoader { @NotNull @Override protected Class findClass(@NotNull String name) throws ClassNotFoundException { - String file = name.replace('.', '/') + ".class"; - if (state.getOutputFiles().contains(file)) { - byte[] bytes = state.asBytes(file); + String classFilePath = name.replace('.', '/') + ".class"; + + OutputFile outputFile = state.get(classFilePath); + if (outputFile != null) { + byte[] bytes = outputFile.asByteArray(); return defineClass(name, bytes, 0, bytes.length); } + return super.findClass(name); } diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CompileEnvironmentUtil.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CompileEnvironmentUtil.java index 7be6291ef5d..28026f6a71d 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CompileEnvironmentUtil.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CompileEnvironmentUtil.java @@ -26,13 +26,14 @@ import jet.modules.AllModules; import jet.modules.Module; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.OutputFile; import org.jetbrains.jet.cli.common.CLIConfigurationKeys; import org.jetbrains.jet.cli.common.messages.MessageCollector; import org.jetbrains.jet.cli.common.messages.MessageRenderer; import org.jetbrains.jet.cli.common.modules.ModuleDescription; import org.jetbrains.jet.cli.common.modules.ModuleXmlParser; -import org.jetbrains.jet.OutputDirector; -import org.jetbrains.jet.cli.common.outputUtils.OutputUtilsPackage; +import org.jetbrains.jet.cli.common.output.OutputDirector; +import org.jetbrains.jet.cli.common.output.outputUtils.OutputUtilsPackage; import org.jetbrains.jet.cli.jvm.JVMConfigurationKeys; import org.jetbrains.jet.codegen.ClassFileFactory; import org.jetbrains.jet.codegen.GeneratedClassLoader; @@ -170,7 +171,7 @@ public class CompileEnvironmentUtil { } // TODO: includeRuntime should be not a flag but a path to runtime - private static void doWriteToJar(ClassFileFactory factory, OutputStream fos, @Nullable FqName mainClass, boolean includeRuntime) { + private static void doWriteToJar(ClassFileFactory outputFiles, OutputStream fos, @Nullable FqName mainClass, boolean includeRuntime) { try { Manifest manifest = new Manifest(); Attributes mainAttributes = manifest.getMainAttributes(); @@ -180,9 +181,9 @@ public class CompileEnvironmentUtil { mainAttributes.putValue("Main-Class", mainClass.asString()); } JarOutputStream stream = new JarOutputStream(fos, manifest); - for (String file : factory.getOutputFiles()) { - stream.putNextEntry(new JarEntry(file)); - stream.write(factory.asBytes(file)); + for (OutputFile outputFile : outputFiles.asList()) { + stream.putNextEntry(new JarEntry(outputFile.getRelativePath())); + stream.write(outputFile.asByteArray()); } if (includeRuntime) { writeRuntimeToJar(stream); @@ -194,11 +195,11 @@ public class CompileEnvironmentUtil { } } - public static void writeToJar(File jarPath, boolean jarRuntime, FqName mainClass, ClassFileFactory moduleFactory) { + public static void writeToJar(File jarPath, boolean jarRuntime, FqName mainClass, ClassFileFactory outputFiles) { FileOutputStream outputStream = null; try { outputStream = new FileOutputStream(jarPath); - doWriteToJar(moduleFactory, outputStream, mainClass, jarRuntime); + doWriteToJar(outputFiles, outputStream, mainClass, jarRuntime); outputStream.close(); } catch (FileNotFoundException e) { @@ -212,7 +213,7 @@ public class CompileEnvironmentUtil { } } - private static void writeRuntimeToJar(final JarOutputStream stream) throws IOException { + private static void writeRuntimeToJar(JarOutputStream stream) throws IOException { File runtimeJarPath = getRuntimeJarPath(); if (runtimeJarPath != null) { JarInputStream jis = new JarInputStream(new FileInputStream(runtimeJarPath)); @@ -254,14 +255,14 @@ public class CompileEnvironmentUtil { @Nullable OutputDirector outputDir, boolean includeRuntime, @Nullable FqName mainClass, - @NotNull ClassFileFactory factory, + @NotNull ClassFileFactory outputFiles, @NotNull MessageCollector messageCollector ) { if (jar != null) { - writeToJar(jar, includeRuntime, mainClass, factory); + writeToJar(jar, includeRuntime, mainClass, outputFiles); } else if (outputDir != null) { - OutputUtilsPackage.writeAll(factory, outputDir, messageCollector); + OutputUtilsPackage.writeAll(outputFiles, outputDir, messageCollector); } else { throw new CompileEnvironmentException("Output directory or jar file is not specified - no files will be saved to the disk"); diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java index 59d695f37ce..0014ac86daa 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java @@ -30,6 +30,7 @@ import com.intellij.testFramework.LightVirtualFile; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.asm4.Type; +import org.jetbrains.jet.OutputFile; import org.jetbrains.jet.analyzer.AnalyzeExhaust; import org.jetbrains.jet.cli.common.messages.AnalyzerWithCompilerReport; import org.jetbrains.jet.cli.common.messages.MessageCollector; @@ -70,7 +71,6 @@ import java.net.URLClassLoader; import java.util.Collections; import java.util.List; - import static org.jetbrains.jet.codegen.AsmUtil.asmTypeByFqNameWithoutInnerClasses; import static org.jetbrains.jet.codegen.binding.CodegenBinding.registerClassNameForScript; @@ -241,8 +241,8 @@ public class ReplInterpreter { compileScript(psiFile.getScript(), scriptClassType, earlierScripts, generationState, CompilationErrorHandler.THROW_EXCEPTION); - for (String file : generationState.getFactory().getOutputFiles()) { - classLoader.addClass(JvmClassName.byInternalName(file.replaceFirst("\\.class$", "")), generationState.getFactory().asBytes(file)); + for (OutputFile outputFile : generationState.getFactory().asList()) { + classLoader.addClass(JvmClassName.byInternalName(outputFile.getRelativePath().replaceFirst("\\.class$", "")), outputFile.asByteArray()); } try { diff --git a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinJavaFileStubProvider.java b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinJavaFileStubProvider.java index 7bbf16e9054..c302815bd0b 100644 --- a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinJavaFileStubProvider.java +++ b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinJavaFileStubProvider.java @@ -77,7 +77,7 @@ public class KotlinJavaFileStubProvider implements CachedValueProvider files) { NamespaceCodegen codegen = state.getFactory().forNamespace(packageFqName, files); codegen.generate(CompilationErrorHandler.THROW_EXCEPTION); - state.getFactory().getOutputFiles(); + state.getFactory().asList(); } }); } @@ -107,7 +107,7 @@ public class KotlinJavaFileStubProvider implements CachedValueProvider files) { NamespaceCodegen namespaceCodegen = state.getFactory().forNamespace(getPackageFqName(), files); namespaceCodegen.generateClassOrObject(classOrObject); - state.getFactory().getOutputFiles(); + state.getFactory().asList(); } }); } diff --git a/compiler/tests/org/jetbrains/jet/codegen/AbstractCheckLocalVariablesTableTest.java b/compiler/tests/org/jetbrains/jet/codegen/AbstractCheckLocalVariablesTableTest.java index ee3f4641bc8..e4524fef960 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/AbstractCheckLocalVariablesTableTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/AbstractCheckLocalVariablesTableTest.java @@ -22,6 +22,8 @@ import com.intellij.openapi.util.io.FileUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.asm4.*; import org.jetbrains.jet.JetTestUtils; +import org.jetbrains.jet.OutputFile; +import org.jetbrains.jet.OutputFileCollection; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.test.TestCaseWithTmpdir; @@ -65,14 +67,14 @@ public abstract class AbstractCheckLocalVariablesTableTest extends TestCaseWithT JetFile psiFile = JetTestUtils.createFile(ktFile.getName(), text, jetCoreEnvironment.getProject()); assert psiFile != null; - ClassFileFactory factory = GenerationUtils.compileFileGetClassFileFactoryForTest(psiFile); + OutputFileCollection outputFiles = GenerationUtils.compileFileGetClassFileFactoryForTest(psiFile); String modifiedTestName = ktFile.getName().replace(".kt", ".class"); boolean isClassFound = false; - for (String filename : factory.getOutputFiles()) { - if (filename.equals(modifiedTestName)) { + for (OutputFile outputFile : outputFiles.asList()) { + if (outputFile.getRelativePath().equals(modifiedTestName)) { isClassFound = true; - ClassReader cr = new ClassReader(factory.asBytes(filename)); + ClassReader cr = new ClassReader(outputFile.asByteArray()); List expectedLocalVariables = parseExpectations(); List actualLocalVariables = readLocalVariable(cr, parseMethodName()); diff --git a/compiler/tests/org/jetbrains/jet/codegen/DxChecker.java b/compiler/tests/org/jetbrains/jet/codegen/DxChecker.java index 93b8d0a5367..8df294b058f 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/DxChecker.java +++ b/compiler/tests/org/jetbrains/jet/codegen/DxChecker.java @@ -19,6 +19,7 @@ package org.jetbrains.jet.codegen; import com.android.dx.command.dexer.Main; import com.android.dx.dex.cf.CfTranslator; import junit.framework.Assert; +import org.jetbrains.jet.OutputFile; import java.io.PrintWriter; import java.io.StringWriter; @@ -34,15 +35,15 @@ public class DxChecker { private DxChecker() { } - public static void check(ClassFileFactory factory) { + public static void check(ClassFileFactory outputFiles) { Main.Arguments arguments = new Main.Arguments(); String[] array = new String[1]; array[0] = "testArgs"; arguments.parse(array); - for (String file : factory.getOutputFiles()) { + for (OutputFile file : outputFiles.asList()) { try { - CfTranslator.translate(file, factory.asBytes(file), arguments.cfOptions, arguments.dexOptions); + CfTranslator.translate(file.getRelativePath(), file.asByteArray(), arguments.cfOptions, arguments.dexOptions); } catch (Throwable e) { Assert.fail(generateExceptionMessage(e)); diff --git a/compiler/tests/org/jetbrains/jet/codegen/GenerateNotNullAssertionsTest.java b/compiler/tests/org/jetbrains/jet/codegen/GenerateNotNullAssertionsTest.java index 49cd3f8afcb..cb775a4c31a 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/GenerateNotNullAssertionsTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/GenerateNotNullAssertionsTest.java @@ -23,10 +23,8 @@ import org.jetbrains.asm4.ClassReader; import org.jetbrains.asm4.ClassVisitor; import org.jetbrains.asm4.MethodVisitor; import org.jetbrains.asm4.Opcodes; -import org.jetbrains.jet.ConfigurationKind; -import org.jetbrains.jet.JetTestUtils; -import org.jetbrains.jet.TestJdkKind; -import org.jetbrains.jet.outputUtils.OutputUtilsPackage; +import org.jetbrains.jet.*; +import org.jetbrains.jet.cli.common.output.outputUtils.OutputUtilsPackage; import org.jetbrains.jet.cli.jvm.JVMConfigurationKeys; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.config.CompilerConfiguration; @@ -82,9 +80,9 @@ public class GenerateNotNullAssertionsTest extends CodegenTestCase { public void testNoAssertionsForKotlinFromBinary() throws Exception { setUpEnvironment(true, false); loadFile("notNullAssertions/noAssertionsForKotlin.kt"); - ClassFileFactory factory = generateClassesInFile(); + OutputFileCollection outputFiles = generateClassesInFile(); File compiledDirectory = new File(FileUtil.getTempDirectory(), "kotlin-classes"); - OutputUtilsPackage.writeAllTo(factory, compiledDirectory); + OutputUtilsPackage.writeAllTo(outputFiles, compiledDirectory); setUpEnvironment(true, false, compiledDirectory); loadFile("notNullAssertions/noAssertionsForKotlinMain.kt"); @@ -163,8 +161,10 @@ public class GenerateNotNullAssertionsTest extends CodegenTestCase { } private void assertNoIntrinsicsMethodIsCalled(String className) { - ClassFileFactory classes = generateClassesInFile(); - ClassReader reader = new ClassReader(classes.asBytes(className + ".class")); + OutputFileCollection classes = generateClassesInFile(); + OutputFile file = classes.get(className + ".class"); + assertNotNull(file); + ClassReader reader = new ClassReader(file.asByteArray()); final String intrinsics = JvmClassName.byFqNameWithoutInnerClasses(Intrinsics.class.getName()).getInternalName(); diff --git a/compiler/tests/org/jetbrains/jet/codegen/InnerClassInfoGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/InnerClassInfoGenTest.java index b1ae9289e40..b9dc8802188 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/InnerClassInfoGenTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/InnerClassInfoGenTest.java @@ -21,6 +21,7 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.asm4.ClassReader; import org.jetbrains.asm4.ClassVisitor; import org.jetbrains.jet.ConfigurationKind; +import org.jetbrains.jet.OutputFile; import org.jetbrains.jet.lang.resolve.java.JvmAbi; import java.util.ArrayList; @@ -90,7 +91,9 @@ public class InnerClassInfoGenTest extends CodegenTestCase { @NotNull private List extractInnerClasses(@NotNull String className) { - byte[] bytes = factory.asBytes(className + ".class"); + OutputFile outputFile = factory.get(className + ".class"); + assertNotNull(outputFile); + byte[] bytes = outputFile.asByteArray(); ClassReader reader = new ClassReader(bytes); final List result = new ArrayList(); diff --git a/compiler/tests/org/jetbrains/jet/codegen/KotlinPackageFragmentAnnotationTest.java b/compiler/tests/org/jetbrains/jet/codegen/KotlinPackageFragmentAnnotationTest.java index 85cfb0d2981..ea5387c09da 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/KotlinPackageFragmentAnnotationTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/KotlinPackageFragmentAnnotationTest.java @@ -18,6 +18,8 @@ package org.jetbrains.jet.codegen; import jet.KotlinPackageFragment; import org.jetbrains.jet.ConfigurationKind; +import org.jetbrains.jet.OutputFile; +import org.jetbrains.jet.OutputFileCollection; import org.jetbrains.jet.lang.resolve.java.AbiVersionUtil; import org.jetbrains.jet.lang.resolve.java.JvmClassName; import org.jetbrains.jet.lang.resolve.java.PackageClassUtils; @@ -38,11 +40,13 @@ public class KotlinPackageFragmentAnnotationTest extends CodegenTestCase { loadText("package " + NAMESPACE_NAME + "\n\nfun foo() = 42\n"); String facadeFileName = JvmClassName.byFqNameWithoutInnerClasses(PackageClassUtils.getPackageClassFqName(NAMESPACE_NAME)).getInternalName() + ".class"; - ClassFileFactory factory = generateClassesInFile(); - for (String fileName : factory.getOutputFiles()) { - if (!fileName.equals(facadeFileName)) { + OutputFileCollection outputFiles = generateClassesInFile(); + for (OutputFile outputFile : outputFiles.asList()) { + String filePath = outputFile.getRelativePath(); + + if (!filePath.equals(facadeFileName)) { // The file which is not a facade is a package fragment - String fqName = fileName.substring(0, fileName.length() - ".class".length()).replace('/', '.'); + String fqName = filePath.substring(0, filePath.length() - ".class".length()).replace('/', '.'); Class aClass = generateClass(fqName); Class annotationClass = getCorrespondingAnnotationClass(KotlinPackageFragment.class); @@ -60,6 +64,6 @@ public class KotlinPackageFragmentAnnotationTest extends CodegenTestCase { } } - fail("No package fragment was found: " + factory.getOutputFiles()); + fail("No package fragment was found: " + outputFiles.asList()); } } diff --git a/compiler/tests/org/jetbrains/jet/codegen/LineNumberTest.java b/compiler/tests/org/jetbrains/jet/codegen/LineNumberTest.java index a9af70602e6..13fe3c0ff29 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/LineNumberTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/LineNumberTest.java @@ -22,11 +22,8 @@ import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.util.text.StringUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.asm4.*; -import org.jetbrains.jet.ConfigurationKind; -import org.jetbrains.jet.JetTestCaseBuilder; -import org.jetbrains.jet.JetTestUtils; -import org.jetbrains.jet.TestJdkKind; -import org.jetbrains.jet.outputUtils.OutputUtilsPackage; +import org.jetbrains.jet.*; +import org.jetbrains.jet.cli.common.output.outputUtils.OutputUtilsPackage; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.codegen.state.GenerationState; import org.jetbrains.jet.lang.psi.JetFile; @@ -69,8 +66,8 @@ public class LineNumberTest extends TestCaseWithTmpdir { "package test;\n\npublic fun " + LINE_NUMBER_FUN + "(): Int = 0\n", environment.getProject()); - ClassFileFactory classFileFactory = GenerationUtils.compileFileGetClassFileFactoryForTest(psiFile); - OutputUtilsPackage.writeAllTo(classFileFactory, tmpdir); + OutputFileCollection outputFiles = GenerationUtils.compileFileGetClassFileFactoryForTest(psiFile); + OutputUtilsPackage.writeAllTo(outputFiles, tmpdir); } @NotNull @@ -112,12 +109,12 @@ public class LineNumberTest extends TestCaseWithTmpdir { private static List extractActualLineNumbersFromBytecode(@NotNull GenerationState state, boolean testFunInvoke) { ClassFileFactory factory = state.getFactory(); List actualLineNumbers = Lists.newArrayList(); - for (String filename : factory.getOutputFiles()) { - if (PackageClassUtils.isPackageClassFqName(new FqName(FileUtil.getNameWithoutExtension(filename)))) { + for (OutputFile outputFile : factory.asList()) { + if (PackageClassUtils.isPackageClassFqName(new FqName(FileUtil.getNameWithoutExtension(outputFile.getRelativePath())))) { // Don't test line numbers in *Package facade classes continue; } - ClassReader cr = new ClassReader(factory.asBytes(filename)); + ClassReader cr = new ClassReader(outputFile.asByteArray()); try { List lineNumbers = testFunInvoke ? readTestFunLineNumbers(cr) : readAllLineNumbers(cr); actualLineNumbers.addAll(lineNumbers); @@ -332,7 +329,9 @@ public class LineNumberTest extends TestCaseWithTmpdir { JetFile foo = createPsiFile("staticDelegate/foo.kt"); JetFile bar = createPsiFile("staticDelegate/bar.kt"); GenerationState state = GenerationUtils.compileManyFilesGetGenerationStateForTest(foo.getProject(), Arrays.asList(foo, bar)); - ClassReader reader = new ClassReader(state.getFactory().asBytes(PackageClassUtils.getPackageClassName(FqName.ROOT) + ".class")); + OutputFile file = state.getFactory().get(PackageClassUtils.getPackageClassName(FqName.ROOT) + ".class"); + assertNotNull(file); + ClassReader reader = new ClassReader(file.asByteArray()); // There must be exactly one line number attribute for each static delegate in namespace.class, and it should point to the first // line. There are two static delegates in this test, hence the [1, 1] diff --git a/compiler/tests/org/jetbrains/jet/codegen/OuterClassGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/OuterClassGenTest.java index 96620043a78..3878d5eeb59 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/OuterClassGenTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/OuterClassGenTest.java @@ -22,9 +22,7 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.asm4.ClassReader; import org.jetbrains.asm4.ClassVisitor; import org.jetbrains.asm4.Opcodes; -import org.jetbrains.jet.ConfigurationKind; -import org.jetbrains.jet.JetTestUtils; -import org.jetbrains.jet.TestJdkKind; +import org.jetbrains.jet.*; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import java.io.File; @@ -113,8 +111,10 @@ public class OuterClassGenTest extends CodegenTestCase { private ClassReader getKotlinClassReader(@NotNull String kotlinClassName) { loadFile("outerClassInfo/outerClassInfo.kt"); - ClassFileFactory classFileFactory = generateClassesInFile(); - return new ClassReader(classFileFactory.asBytes(kotlinClassName.replace('.', '/') + ".class")); + OutputFileCollection outputFiles = generateClassesInFile(); + OutputFile outputFile = outputFiles.get(kotlinClassName.replace('.', '/') + ".class"); + assertNotNull(outputFile); + return new ClassReader(outputFile.asByteArray()); } private void checkInfo(ClassReader kotlinReader, ClassReader javaReader) { diff --git a/compiler/tests/org/jetbrains/jet/codegen/SourceInfoGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/SourceInfoGenTest.java index 54c0aa57ab3..832a4c46287 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/SourceInfoGenTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/SourceInfoGenTest.java @@ -19,6 +19,7 @@ import org.jetbrains.asm4.ClassReader; import org.jetbrains.asm4.ClassVisitor; import org.jetbrains.asm4.Opcodes; import org.jetbrains.jet.ConfigurationKind; +import org.jetbrains.jet.OutputFile; public class SourceInfoGenTest extends CodegenTestCase { @@ -45,7 +46,10 @@ public class SourceInfoGenTest extends CodegenTestCase { } private String getProducerInfo(String name) { - ClassReader classReader = new ClassReader(generateClassesInFile().asBytes(name)); + OutputFile file = generateClassesInFile().get(name); + assertNotNull(file); + + ClassReader classReader = new ClassReader(file.asByteArray()); final String [] producer = new String [1]; classReader.accept(new ClassVisitor(Opcodes.ASM4) { diff --git a/compiler/tests/org/jetbrains/jet/codegen/SyntheticMethodForAnnotatedPropertyGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/SyntheticMethodForAnnotatedPropertyGenTest.java index 289f8635e70..590ba1d634b 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/SyntheticMethodForAnnotatedPropertyGenTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/SyntheticMethodForAnnotatedPropertyGenTest.java @@ -18,6 +18,7 @@ package org.jetbrains.jet.codegen; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.ConfigurationKind; +import org.jetbrains.jet.OutputFile; import org.jetbrains.jet.lang.resolve.java.JvmAbi; import org.jetbrains.jet.lang.resolve.java.PackageClassUtils; import org.jetbrains.jet.lang.resolve.name.FqName; @@ -51,10 +52,12 @@ public class SyntheticMethodForAnnotatedPropertyGenTest extends CodegenTestCase public void testTopLevel() { loadFile(); String packageClassName = PackageClassUtils.getPackageClassName(FqName.ROOT); - for (String fileName : generateClassesInFile().getOutputFiles()) { - if (fileName.startsWith(packageClassName) && !fileName.equals(packageClassName + ".class")) { + for (OutputFile outputFile : generateClassesInFile().asList()) { + String filPath = outputFile.getRelativePath(); + + if (filPath.startsWith(packageClassName) && !filPath.equals(packageClassName + ".class")) { // This should be package$src class - Class a = generateClass(fileName.substring(0, fileName.length() - ".class".length())); + Class a = generateClass(filPath.substring(0, filPath.length() - ".class".length())); assertAnnotatedSyntheticMethodExistence(true, a); } } diff --git a/compiler/tests/org/jetbrains/jet/codegen/flags/AbstractWriteFlagsTest.java b/compiler/tests/org/jetbrains/jet/codegen/flags/AbstractWriteFlagsTest.java index 559ae0fce25..a1efac7b07d 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/flags/AbstractWriteFlagsTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/flags/AbstractWriteFlagsTest.java @@ -21,8 +21,9 @@ import com.intellij.testFramework.UsefulTestCase; import org.jetbrains.asm4.*; import org.jetbrains.jet.ConfigurationKind; import org.jetbrains.jet.JetTestUtils; +import org.jetbrains.jet.OutputFile; +import org.jetbrains.jet.OutputFileCollection; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; -import org.jetbrains.jet.codegen.ClassFileFactory; import org.jetbrains.jet.codegen.GenerationUtils; import org.jetbrains.jet.lang.psi.JetFile; @@ -77,35 +78,37 @@ public abstract class AbstractWriteFlagsTest extends UsefulTestCase { JetFile psiFile = JetTestUtils.createFile(ktFile.getName(), fileText, jetCoreEnvironment.getProject()); assertTrue("Cannot create JetFile from text", psiFile != null); - ClassFileFactory factory = GenerationUtils.compileFileGetClassFileFactoryForTest(psiFile); + OutputFileCollection outputFiles = GenerationUtils.compileFileGetClassFileFactoryForTest(psiFile); List testedObjects = parseExpectedTestedObject(fileText); for (TestedObject testedObject : testedObjects) { String className = null; - for (String filename : factory.getOutputFiles()) { - if (testedObject.isFullContainingClassName && filename.equals(testedObject.containingClass + ".class")) { - className = filename; + for (OutputFile outputFile : outputFiles.asList()) { + String filePath = outputFile.getRelativePath(); + if (testedObject.isFullContainingClassName && filePath.equals(testedObject.containingClass + ".class")) { + className = filePath; } - else if (!testedObject.isFullContainingClassName && filename.startsWith(testedObject.containingClass)) { - className = filename; + else if (!testedObject.isFullContainingClassName && filePath.startsWith(testedObject.containingClass)) { + className = filePath; } } - if (className == null) { - throw new AssertionError("Couldn't find a class file with name " + testedObject.containingClass); - } + assertNotNull("Couldn't find a class file with name " + testedObject.containingClass, className); - ClassReader cr = new ClassReader(factory.asBytes(className)); + OutputFile outputFile = outputFiles.get(className); + assertNotNull(outputFile); + + ClassReader cr = new ClassReader(outputFile.asByteArray()); TestClassVisitor classVisitor; classVisitor = getClassVisitor(testedObject.kind, testedObject.name); cr.accept(classVisitor, ClassReader.SKIP_CODE); - boolean isObjectExists = false == Boolean.valueOf(findStringWithPrefixes(testedObject.textData, "// ABSENT: ")); + boolean isObjectExists = !Boolean.valueOf(findStringWithPrefixes(testedObject.textData, "// ABSENT: ")); assertEquals( "Wrong object existence state: " + testedObject, isObjectExists, classVisitor.isExists()); int expectedAccess = getExpectedFlags(testedObject.textData); if (isObjectExists) { - assertEquals("Wrong access flag for " + testedObject + " \n" + factory.asText(className), expectedAccess, classVisitor.getAccess()); + assertEquals("Wrong access flag for " + testedObject + " \n" + outputFile.asText(), expectedAccess, classVisitor.getAccess()); } } } diff --git a/idea/src/org/jetbrains/jet/plugin/internal/codewindow/BytecodeToolwindow.java b/idea/src/org/jetbrains/jet/plugin/internal/codewindow/BytecodeToolwindow.java index b245a92698a..cf26fd678df 100644 --- a/idea/src/org/jetbrains/jet/plugin/internal/codewindow/BytecodeToolwindow.java +++ b/idea/src/org/jetbrains/jet/plugin/internal/codewindow/BytecodeToolwindow.java @@ -31,8 +31,12 @@ import com.intellij.openapi.util.Pair; import com.intellij.openapi.util.text.StringUtil; import com.intellij.util.Alarm; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.OutputFile; +import org.jetbrains.jet.OutputFileCollection; import org.jetbrains.jet.analyzer.AnalyzeExhaust; -import org.jetbrains.jet.codegen.*; +import org.jetbrains.jet.codegen.ClassBuilderFactories; +import org.jetbrains.jet.codegen.CompilationErrorHandler; +import org.jetbrains.jet.codegen.KotlinCodegenFacade; import org.jetbrains.jet.codegen.state.GenerationState; import org.jetbrains.jet.codegen.state.Progress; import org.jetbrains.jet.lang.psi.JetFile; @@ -105,12 +109,12 @@ public class BytecodeToolwindow extends JPanel implements Disposable { StringBuilder answer = new StringBuilder(); - ClassFileFactory factory = state.getFactory(); - for (String filename : factory.getOutputFiles()) { + OutputFileCollection outputFiles = state.getFactory(); + for (OutputFile outputFile : outputFiles.asList()) { answer.append("// ================"); - answer.append(filename); + answer.append(outputFile.getRelativePath()); answer.append(" =================\n"); - answer.append(factory.asText(filename)).append("\n\n"); + answer.append(outputFile.asText()).append("\n\n"); } return answer.toString(); diff --git a/idea/tests/org/jetbrains/jet/plugin/debugger/PositionManagerTestCase.java b/idea/tests/org/jetbrains/jet/plugin/debugger/PositionManagerTestCase.java index 122e0ab5ccd..ae6fcd8d677 100644 --- a/idea/tests/org/jetbrains/jet/plugin/debugger/PositionManagerTestCase.java +++ b/idea/tests/org/jetbrains/jet/plugin/debugger/PositionManagerTestCase.java @@ -34,7 +34,8 @@ import com.intellij.testFramework.PsiTestUtil; import com.sun.jdi.Location; import com.sun.jdi.ReferenceType; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.codegen.ClassFileFactory; +import org.jetbrains.jet.OutputFile; +import org.jetbrains.jet.OutputFileCollection; import org.jetbrains.jet.codegen.GenerationUtils; import org.jetbrains.jet.codegen.state.GenerationState; import org.jetbrains.jet.lang.psi.JetFile; @@ -126,9 +127,10 @@ public abstract class PositionManagerTestCase extends MultiFileTestCase { return breakpoints; } - private static Map getReferenceMap(ClassFileFactory classFileFactory) { + private static Map getReferenceMap(OutputFileCollection outputFiles) { Map referencesByName = Maps.newHashMap(); - for (String classFileName : classFileFactory.getOutputFiles()) { + for (OutputFile outputFile : outputFiles.asList()) { + String classFileName = outputFile.getRelativePath(); String name = classFileName.substring(0, classFileName.lastIndexOf('.')); referencesByName.put(name, new MockReferenceType(name)); }