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

Fix build after change api

Browse Source
This commit is contained in:
Zalim Bashorov
2013-11-08 12:21:33 +04:00
parent ae8ac28ddc
commit 4cea0a3de4
16 changed files with 112 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/backend/src/org/jetbrains/jet/codegen/GeneratedClassLoader.java
+7 -3
View File
@@ -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);
}
compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CompileEnvironmentUtil.java
+13 -12
View File
@@ -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");
compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java
+3 -3
View File
@@ -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 {
compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinJavaFileStubProvider.java
+2 -2
View File
@@ -77,7 +77,7 @@ public class KotlinJavaFileStubProvider implements CachedValueProvider<PsiJavaFi
public void generate(@NotNull GenerationState state, @NotNull Collection<JetFile> 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<PsiJavaFi
public void generate(@NotNull GenerationState state, @NotNull Collection<JetFile> files) {
NamespaceCodegen namespaceCodegen = state.getFactory().forNamespace(getPackageFqName(), files);
namespaceCodegen.generateClassOrObject(classOrObject);
state.getFactory().getOutputFiles();
state.getFactory().asList();
}
});
}
compiler/tests/org/jetbrains/jet/codegen/AbstractCheckLocalVariablesTableTest.java
+6 -4
View File
@@ -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<LocalVariable> expectedLocalVariables = parseExpectations();
List<LocalVariable> actualLocalVariables = readLocalVariable(cr, parseMethodName());
compiler/tests/org/jetbrains/jet/codegen/DxChecker.java
+4 -3
View File
@@ -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));
compiler/tests/org/jetbrains/jet/codegen/GenerateNotNullAssertionsTest.java
+8 -8
View File
@@ -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();
compiler/tests/org/jetbrains/jet/codegen/InnerClassInfoGenTest.java
+4 -1
View File
@@ -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<InnerClassAttribute> 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<InnerClassAttribute> result = new ArrayList<InnerClassAttribute>();
compiler/tests/org/jetbrains/jet/codegen/KotlinPackageFragmentAnnotationTest.java
+9 -5
View File
@@ -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<? extends Annotation> 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());
}
}
compiler/tests/org/jetbrains/jet/codegen/LineNumberTest.java
+10 -11
View File
@@ -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<Integer> extractActualLineNumbersFromBytecode(@NotNull GenerationState state, boolean testFunInvoke) {
ClassFileFactory factory = state.getFactory();
List<Integer> 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<Integer> 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]
compiler/tests/org/jetbrains/jet/codegen/OuterClassGenTest.java
+5 -5
View File
@@ -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) {
compiler/tests/org/jetbrains/jet/codegen/SourceInfoGenTest.java
+5 -1
View File
@@ -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) {
compiler/tests/org/jetbrains/jet/codegen/SyntheticMethodForAnnotatedPropertyGenTest.java
+6 -3
View File
@@ -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);
}
}
compiler/tests/org/jetbrains/jet/codegen/flags/AbstractWriteFlagsTest.java
+16 -13
View File
@@ -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<TestedObject> 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());
}
}
}
idea/src/org/jetbrains/jet/plugin/internal/codewindow/BytecodeToolwindow.java
+9 -5
View File
@@ -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();
idea/tests/org/jetbrains/jet/plugin/debugger/PositionManagerTestCase.java
+5 -3
View File
@@ -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<String, ReferenceType> getReferenceMap(ClassFileFactory classFileFactory) {
private static Map<String, ReferenceType> getReferenceMap(OutputFileCollection outputFiles) {
Map<String, ReferenceType> 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));
}