Remove ClassLoaderIsolationUtil

Minimize usages of jet.* in Java code: this will help in migration of jet.* to
package kotlin. Since tests will work with fq names instead of Class<?>
instances from now on, ClassLoaderIsolationUtil is useless now (except for one
unrelated method, which was moved to CodegenTestUtil)

compiler/tests/org/jetbrains/jet/codegen/AnnotationGenTest.java

@@ -16,7 +16,7 @@
 
 package org.jetbrains.jet.codegen;
 
-import jet.JetObject;
+import com.google.common.collect.Sets;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.ConfigurationKind;
@@ -222,17 +222,17 @@ public class AnnotationGenTest extends CodegenTestCase {
         assertNotNull(annotation);
     }
 
-    public void testSimplestAnnotationClass() throws NoSuchFieldException, NoSuchMethodException {
+    public void testSimplestAnnotationClass() {
         loadText("annotation class A");
-        Class aClass = generateClass("A");
+        Class<?> aClass = generateClass("A");
         Class[] interfaces = aClass.getInterfaces();
-        assertEquals(2, interfaces.length);
         assertEquals(0, aClass.getDeclaredMethods().length);
-        Class annotationClass = getCorrespondingClass(Annotation.class);
-        Class jetObjectClass = getCorrespondingClass(JetObject.class);
-        assertTrue(annotationClass == interfaces[0] || annotationClass == interfaces[1]);
-        assertTrue(jetObjectClass == interfaces[0] || jetObjectClass == interfaces[1]);
         assertTrue(aClass.isAnnotation());
+        assertEquals(2, interfaces.length);
+        assertEquals(
+                Sets.newHashSet("java.lang.annotation.Annotation", "jet.JetObject"),
+                Sets.newHashSet(interfaces[0].getName(), interfaces[1].getName())
+        );
     }
 
     public void testAnnotationClassWithStringProperty()

compiler/tests/org/jetbrains/jet/codegen/ClassLoaderIsolationUtil.java

@@ -1,46 +0,0 @@
-package org.jetbrains.jet.codegen;
-
-import junit.framework.Assert;
-import org.jetbrains.annotations.NotNull;
-
-import java.lang.annotation.Annotation;
-import java.lang.reflect.InvocationTargetException;
-
-import static junit.framework.Assert.*;
-
-public class ClassLoaderIsolationUtil {
-
-    public static void assertEquals(Class<?> expected, Class<?> actual) {
-        if (actual == null) {
-            assertNull(expected);
-        }
-        else Assert.assertEquals(getClassFromClassLoader(expected, actual.getClassLoader()), actual);
-    }
-
-    public static Class<? extends Annotation> getAnnotationClass(Class<? extends Annotation> annotationClass, ClassLoader classLoader) {
-        return (Class<? extends Annotation>) getClassFromClassLoader(annotationClass, classLoader);
-    }
-
-    public static Object getAnnotationAttribute(Object annotation, String name) {
-        try {
-            return annotation.getClass().getMethod(name).invoke(annotation);
-        }
-        catch (Exception e) {
-            e.printStackTrace();
-            fail(e.getMessage());
-        }
-        return null;
-    }
-
-    @NotNull
-    public static Class<?> getClassFromClassLoader(Class<?> classForName, ClassLoader classLoader) {
-        try {
-            return classLoader.loadClass(classForName.getName());
-        }
-        catch (ClassNotFoundException e) {
-            e.printStackTrace();
-            fail(e.getMessage());
-        }
-        return null;
-    }
-}

compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java

@@ -38,6 +38,7 @@ import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileRuntime;
 import org.jetbrains.jet.lang.psi.JetPsiUtil;
 import org.jetbrains.jet.lang.resolve.name.FqName;
+import org.jetbrains.jet.utils.UtilsPackage;
 
 import java.io.File;
 import java.io.IOException;
@@ -282,11 +283,14 @@ public abstract class CodegenTestCase extends UsefulTestCase {
         return method;
     }
 
-    public Class<? extends Annotation> getCorrespondingAnnotationClass(Class<? extends Annotation> classForName) {
+    @NotNull
-        return ClassLoaderIsolationUtil.getAnnotationClass(classForName, initializedClassLoader);
+    public Class<? extends Annotation> loadAnnotationClassQuietly(@NotNull String fqName) {
-    }
+        try {
-
+            //noinspection unchecked
-    public Class<?> getCorrespondingClass(Class<?> classForName) {
+            return (Class<? extends Annotation>) initializedClassLoader.loadClass(fqName);
-        return ClassLoaderIsolationUtil.getClassFromClassLoader(classForName, initializedClassLoader);
+        }
+        catch (ClassNotFoundException e) {
+            throw UtilsPackage.rethrow(e);
+        }
     }
 }

compiler/tests/org/jetbrains/jet/codegen/CodegenTestUtil.java

@@ -138,4 +138,14 @@ public class CodegenTestUtil {
         }
         return r;
     }
+
+    @Nullable
+    public static Object getAnnotationAttribute(@NotNull Object annotation, @NotNull String name) {
+        try {
+            return annotation.getClass().getMethod(name).invoke(annotation);
+        }
+        catch (Exception e) {
+            throw UtilsPackage.rethrow(e);
+        }
+    }
 }

compiler/tests/org/jetbrains/jet/codegen/JUnitUsageGenTest.java

@@ -50,9 +50,10 @@ public class JUnitUsageGenTest extends CodegenTestCase {
         Class<?> packageClass = generatePackageClass();
         Method method = packageClass.getMethod("foo", Method.class);
         method.setAccessible(true);
-        Annotation annotation = method.getAnnotation(getCorrespondingAnnotationClass(Test.class));
+        Annotation annotation = method.getAnnotation(loadAnnotationClassQuietly(Test.class.getName()));
-        assertEquals(ClassLoaderIsolationUtil.getAnnotationAttribute(annotation, "timeout"), 0l);
+        assertEquals(CodegenTestUtil.getAnnotationAttribute(annotation, "timeout"), Long.valueOf(0));
-        ClassLoaderIsolationUtil.assertEquals(Test.None.class, (Class<?>) ClassLoaderIsolationUtil.getAnnotationAttribute(annotation,
+        Class<?> expected = (Class<?>) CodegenTestUtil.getAnnotationAttribute(annotation, "expected");
-                                                                                                                          "expected"));
+        assertNotNull(expected);
+        assertEquals(Test.None.class.getName(), expected.getName());
     }
 }

compiler/tests/org/jetbrains/jet/codegen/JetValueParameterAnnotationTest.java

@@ -16,7 +16,6 @@
 
 package org.jetbrains.jet.codegen;
 
-import jet.runtime.typeinfo.JetValueParameter;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.ConfigurationKind;
 
@@ -30,24 +29,19 @@ public class JetValueParameterAnnotationTest extends CodegenTestCase {
         createEnvironmentWithMockJdkAndIdeaAnnotations(ConfigurationKind.JDK_ONLY);
     }
 
+    private static class ValueParameter {
+        public final String name;
+        public final String type;
+
+        private ValueParameter(@NotNull String name, @NotNull String type) {
+            this.name = name;
+            this.type = type;
+        }
+    }
+
     @NotNull
-    private static JetValueParameter valueParameter(@NotNull final String name, final boolean nullable) {
+    private static ValueParameter valueParameter(@NotNull String name, boolean nullable) {
-        return new JetValueParameter() {
+        return new ValueParameter(name, nullable ? "?" : "");
-            @Override
-            public String name() {
-                return name;
-            }
-
-            @Override
-            public String type() {
-                return nullable ? "?" : "";
-            }
-
-            @Override
-            public Class<? extends Annotation> annotationType() {
-                return JetValueParameter.class;
-            }
-        };
     }
 
     public void testOneNotNullParam() {
@@ -95,7 +89,7 @@ public class JetValueParameterAnnotationTest extends CodegenTestCase {
         );
     }
 
-    private void doTest(@NotNull String code, @NotNull JetValueParameter... expected) {
+    private void doTest(@NotNull String code, @NotNull ValueParameter... expected) {
         loadText(code);
 
         Annotation[][] annotations = generateFunction().getParameterAnnotations();
@@ -104,9 +98,9 @@ public class JetValueParameterAnnotationTest extends CodegenTestCase {
         for (int i = 0, length = annotations.length; i < length; i++) {
             assertSize(1, annotations[i]);
             Annotation annotation = annotations[i][0];
-            ClassLoaderIsolationUtil.assertEquals(JetValueParameter.class, annotation.annotationType());
+            assertEquals("jet.runtime.typeinfo.JetValueParameter", annotation.annotationType().getName());
-            assertEquals(expected[i].name(), ClassLoaderIsolationUtil.getAnnotationAttribute(annotation, "name"));
+            assertEquals(expected[i].name, CodegenTestUtil.getAnnotationAttribute(annotation, "name"));
-            assertEquals(expected[i].type(), ClassLoaderIsolationUtil.getAnnotationAttribute(annotation, "type"));
+            assertEquals(expected[i].type, CodegenTestUtil.getAnnotationAttribute(annotation, "type"));
         }
     }
 }

compiler/tests/org/jetbrains/jet/codegen/KotlinClassAnnotationTest.java

@@ -16,10 +16,10 @@
 
 package org.jetbrains.jet.codegen;
 
-import jet.KotlinClass;
 import org.jetbrains.jet.ConfigurationKind;
 import org.jetbrains.jet.descriptors.serialization.ClassData;
 import org.jetbrains.jet.descriptors.serialization.JavaProtoBufUtil;
+import org.jetbrains.jet.lang.resolve.java.JvmAnnotationNames;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
 
@@ -48,13 +48,15 @@ public class KotlinClassAnnotationTest extends CodegenTestCase {
                  "}\n");
         Class aClass = generateClass(PACKAGE_NAME + "." + CLASS_NAME);
 
-        Class<? extends Annotation> annotationClass = getCorrespondingAnnotationClass(KotlinClass.class);
+        Class<? extends Annotation> annotationClass = loadAnnotationClassQuietly(JvmAnnotationNames.KOTLIN_CLASS.asString());
         assertTrue(aClass.isAnnotationPresent(annotationClass));
         Annotation kotlinClass = aClass.getAnnotation(annotationClass);
 
-        ClassData data = JavaProtoBufUtil.readClassDataFrom((String[]) ClassLoaderIsolationUtil.getAnnotationAttribute(kotlinClass, "data"));
+        String[] data = (String[]) CodegenTestUtil.getAnnotationAttribute(kotlinClass, "data");
+        assertNotNull(data);
+        ClassData classData = JavaProtoBufUtil.readClassDataFrom(data);
 
-        Set<String> callableNames = collectCallableNames(data.getClassProto().getMemberList(), data.getNameResolver());
+        Set<String> callableNames = collectCallableNames(classData.getClassProto().getMemberList(), classData.getNameResolver());
         assertSameElements(Arrays.asList("foo", "bar"), callableNames);
     }
 }

compiler/tests/org/jetbrains/jet/codegen/KotlinPackageAnnotationTest.java

@@ -16,13 +16,13 @@
 
 package org.jetbrains.jet.codegen;
 
-import jet.KotlinPackage;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.ConfigurationKind;
 import org.jetbrains.jet.descriptors.serialization.JavaProtoBufUtil;
 import org.jetbrains.jet.descriptors.serialization.NameResolver;
 import org.jetbrains.jet.descriptors.serialization.PackageData;
 import org.jetbrains.jet.descriptors.serialization.ProtoBuf;
+import org.jetbrains.jet.lang.resolve.java.JvmAnnotationNames;
 import org.jetbrains.jet.lang.resolve.java.PackageClassUtils;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 
@@ -52,16 +52,17 @@ public class KotlinPackageAnnotationTest extends CodegenTestCase {
                  "object C\n");
         Class aClass = generateClass(PackageClassUtils.getPackageClassFqName(PACKAGE_NAME).asString());
 
-        Class<? extends Annotation> annotationClass = getCorrespondingAnnotationClass(KotlinPackage.class);
+        Class<? extends Annotation> annotationClass = loadAnnotationClassQuietly(JvmAnnotationNames.KOTLIN_PACKAGE.asString());
         assertTrue(aClass.isAnnotationPresent(annotationClass));
         assertTrue(aClass.isAnnotationPresent(annotationClass));
 
         Annotation kotlinPackage = aClass.getAnnotation(annotationClass);
 
-        PackageData data = JavaProtoBufUtil.readPackageDataFrom((String[]) ClassLoaderIsolationUtil.getAnnotationAttribute(kotlinPackage,
+        String[] data = (String[]) CodegenTestUtil.getAnnotationAttribute(kotlinPackage, "data");
-                                                                                                                           "data"));
+        assertNotNull(data);
+        PackageData packageData = JavaProtoBufUtil.readPackageDataFrom(data);
 
-        Set<String> callableNames = collectCallableNames(data.getPackageProto().getMemberList(), data.getNameResolver());
+        Set<String> callableNames = collectCallableNames(packageData.getPackageProto().getMemberList(), packageData.getNameResolver());
         assertSameElements(callableNames, Arrays.asList("foo", "bar"));
     }
 

compiler/tests/org/jetbrains/jet/codegen/KotlinPackageFragmentAnnotationTest.java

@@ -16,11 +16,11 @@
 
 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.JvmAnnotationNames;
 import org.jetbrains.jet.lang.resolve.java.JvmClassName;
 import org.jetbrains.jet.lang.resolve.java.PackageClassUtils;
 import org.jetbrains.jet.lang.resolve.name.FqName;
@@ -49,16 +49,17 @@ public class KotlinPackageFragmentAnnotationTest extends CodegenTestCase {
                 String fqName = filePath.substring(0, filePath.length() - ".class".length()).replace('/', '.');
                 Class aClass = generateClass(fqName);
 
-                Class<? extends Annotation> annotationClass = getCorrespondingAnnotationClass(KotlinPackageFragment.class);
+                Class<? extends Annotation> annotationClass = loadAnnotationClassQuietly(JvmAnnotationNames.KOTLIN_PACKAGE_FRAGMENT.asString());
 
                 assertTrue("No KotlinPackageFragment annotation on a package fragment",
                            aClass.isAnnotationPresent(annotationClass));
 
                 Annotation kotlinPackageFragment = aClass.getAnnotation(annotationClass);
 
+                Integer version = (Integer) CodegenTestUtil.getAnnotationAttribute(kotlinPackageFragment, "abiVersion");
+                assertNotNull(version);
                 assertTrue("KotlinPackageFragment annotation is written with an unsupported format",
-                           AbiVersionUtil.isAbiVersionCompatible(
+                           AbiVersionUtil.isAbiVersionCompatible(version));
-                                   (Integer) ClassLoaderIsolationUtil.getAnnotationAttribute(kotlinPackageFragment, "abiVersion")));
 
                 return;
             }