Checking errors when loading from Java in tests.

compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadCompiledKotlinTest.java

@@ -48,8 +48,8 @@ public abstract class AbstractLoadCompiledKotlinTest extends TestCaseWithTmpdir
                                                                                   TEST_PACKAGE_FQNAME);
         assert namespaceFromSource != null;
         Assert.assertEquals("test", namespaceFromSource.getName().getName());
-        NamespaceDescriptor namespaceFromClass = LoadDescriptorUtil.loadTestNamespaceFromBinaries(tmpdir, getTestRootDisposable(),
+        NamespaceDescriptor namespaceFromClass = LoadDescriptorUtil.loadTestNamespaceAndBindingContextFromBinaries(
-                                                                                                  ConfigurationKind.JDK_ONLY);
+                tmpdir, getTestRootDisposable(), ConfigurationKind.JDK_ONLY).first;
         compareNamespaces(namespaceFromSource, namespaceFromClass, NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT, txtFile);
     }
 }

compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java

@@ -16,17 +16,19 @@
 
 package org.jetbrains.jet.jvm.compiler;
 
+import com.intellij.openapi.util.Pair;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.ConfigurationKind;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.test.TestCaseWithTmpdir;
 import org.junit.Assert;
 
 import java.io.File;
-import java.util.Collections;
+import java.util.Arrays;
 
 import static org.jetbrains.jet.jvm.compiler.LoadDescriptorUtil.analyzeKotlinAndLoadTestNamespace;
-import static org.jetbrains.jet.jvm.compiler.LoadDescriptorUtil.compileJavaAndLoadTestNamespaceFromBinary;
+import static org.jetbrains.jet.jvm.compiler.LoadDescriptorUtil.compileJavaAndLoadTestNamespaceAndBindingContextFromBinary;
 import static org.jetbrains.jet.test.util.NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT;
 import static org.jetbrains.jet.test.util.NamespaceComparator.compareNamespaces;
 
@@ -44,8 +46,11 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
         File ktFile = new File(javaFile.getPath().replaceFirst("\\.java$", ".kt"));
         File txtFile = new File(javaFile.getPath().replaceFirst("\\.java$", ".txt"));
         NamespaceDescriptor nsa = analyzeKotlinAndLoadTestNamespace(ktFile, myTestRootDisposable, ConfigurationKind.JDK_AND_ANNOTATIONS);
-        NamespaceDescriptor nsb = compileJavaAndLoadTestNamespaceFromBinary(Collections.singletonList(javaFile),
+        Pair<NamespaceDescriptor, BindingContext> nsbAndBindingContext = compileJavaAndLoadTestNamespaceAndBindingContextFromBinary(
-                                                                            tmpdir, myTestRootDisposable, ConfigurationKind.JDK_AND_ANNOTATIONS);
+                Arrays.asList(javaFile, ExpectedLoadErrorsUtil.ANNOTATION_SOURCE_FILE),
+                tmpdir, myTestRootDisposable, ConfigurationKind.JDK_AND_ANNOTATIONS);
+        NamespaceDescriptor nsb = nsbAndBindingContext.first;
+        ExpectedLoadErrorsUtil.checkForLoadErrors(nsb, nsbAndBindingContext.second);
         compareNamespaces(nsa, nsb, DONT_INCLUDE_METHODS_OF_OBJECT, txtFile);
     }
 }

compiler/tests/org/jetbrains/jet/jvm/compiler/ExpectedLoadErrorsUtil.java

@@ -0,0 +1,129 @@
+/*
+ * 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.jvm.compiler;
+
+import com.intellij.util.containers.ContainerUtil;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.DescriptorUtils;
+import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.resolve.DescriptorRenderer;
+
+import java.io.File;
+import java.util.*;
+
+import static com.intellij.testFramework.UsefulTestCase.assertNotNull;
+import static com.intellij.testFramework.UsefulTestCase.assertSameElements;
+
+public class ExpectedLoadErrorsUtil {
+    public static final String ANNOTATION_CLASS_NAME = ExpectLoadError.class.getName();
+    public static final File ANNOTATION_SOURCE_FILE = new File("compiler/tests/" + ANNOTATION_CLASS_NAME.replace('.', '/') + ".java");
+
+    public static void checkForLoadErrors(
+            @NotNull NamespaceDescriptor namespaceFromJava,
+            @NotNull BindingContext bindingContext
+    ) {
+        Map<DeclarationDescriptor, List<String>> expectedErrors = getExpectedLoadErrors(namespaceFromJava);
+        Map<DeclarationDescriptor, List<String>> actualErrors = getActualLoadErrors(bindingContext);
+
+        for (DeclarationDescriptor descriptor : ContainerUtil.union(expectedErrors.keySet(), actualErrors.keySet())) {
+            List<String> actual = actualErrors.get(descriptor);
+            List<String> expected = expectedErrors.get(descriptor);
+            String rendered = DescriptorRenderer.TEXT.render(descriptor);
+
+            assertNotNull("Unexpected load error(s):\n" + actual + "\ncontainer:" + rendered, expected);
+            assertNotNull("Missing load error(s):\n" + expected + "\ncontainer:" + rendered, actual);
+
+            assertSameElements("Unexpected/missing load error(s)\ncontainer:" + rendered, actual, expected);
+        }
+    }
+
+    private static Map<DeclarationDescriptor, List<String>> getExpectedLoadErrors(@NotNull NamespaceDescriptor namespaceFromJava) {
+        final Map<DeclarationDescriptor, List<String>> map = new HashMap<DeclarationDescriptor, List<String>>();
+
+        namespaceFromJava.acceptVoid(new DeclarationDescriptorVisitorEmptyBodies<Void, Void>() {
+            @Override
+            public Void visitNamespaceDescriptor(NamespaceDescriptor descriptor, Void data) {
+                return visitDeclarationRecursively(descriptor, descriptor.getMemberScope());
+            }
+
+            @Override
+            public Void visitClassDescriptor(ClassDescriptor descriptor, Void data) {
+                return visitDeclarationRecursively(descriptor, descriptor.getDefaultType().getMemberScope());
+            }
+
+            @Override
+            public Void visitFunctionDescriptor(FunctionDescriptor descriptor, Void data) {
+                return visitDeclaration(descriptor);
+            }
+
+            @Override
+            public Void visitPropertyDescriptor(PropertyDescriptor descriptor, Void data) {
+                return visitDeclaration(descriptor);
+            }
+
+            private Void visitDeclaration(@NotNull DeclarationDescriptor descriptor) {
+                for (AnnotationDescriptor annotation : descriptor.getAnnotations()) {
+                    ClassDescriptor annotationClass = (ClassDescriptor) annotation.getType().getConstructor().getDeclarationDescriptor();
+                    assert annotationClass != null;
+
+                    if (DescriptorUtils.getFQName(annotationClass).getFqName().equals(ANNOTATION_CLASS_NAME)) {
+
+                        // we expect exactly one annotation argument
+                        CompileTimeConstant<?> argument = annotation.getAllValueArguments().values().iterator().next();
+
+                        String error = (String) argument.getValue();
+                        List<String> errors = Arrays.asList(error.split("\\|"));
+
+                        map.put(descriptor, errors);
+                    }
+                }
+
+                return null;
+            }
+
+            private Void visitDeclarationRecursively(@NotNull DeclarationDescriptor descriptor, @NotNull JetScope memberScope) {
+                for (DeclarationDescriptor member : memberScope.getAllDescriptors()) {
+                    member.acceptVoid(this);
+                }
+
+                return visitDeclaration(descriptor);
+            }
+        });
+
+        return map;
+    }
+
+    private static Map<DeclarationDescriptor, List<String>> getActualLoadErrors(@NotNull BindingContext bindingContext) {
+        Map<DeclarationDescriptor, List<String>> result = new HashMap<DeclarationDescriptor, List<String>>();
+
+        Collection<DeclarationDescriptor> descriptors = bindingContext.getKeys(BindingContext.LOAD_FROM_JAVA_SIGNATURE_ERRORS);
+        for (DeclarationDescriptor descriptor : descriptors) {
+            List<String> errors = bindingContext.get(BindingContext.LOAD_FROM_JAVA_SIGNATURE_ERRORS, descriptor);
+            result.put(descriptor, errors);
+        }
+
+        return result;
+    }
+
+    private ExpectedLoadErrorsUtil() {
+    }
+}

compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java

@@ -18,6 +18,7 @@ package org.jetbrains.jet.jvm.compiler;
 
 import com.intellij.openapi.Disposable;
 import com.intellij.openapi.util.Disposer;
+import com.intellij.openapi.util.Pair;
 import com.intellij.openapi.util.io.FileUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.CompileCompilerDependenciesTest;
@@ -70,7 +71,7 @@ public final class LoadDescriptorUtil {
     )
             throws IOException {
         compileKotlinToDirAndGetAnalyzeExhaust(kotlinFile, outDir, disposable, configurationKind);
-        return loadTestNamespaceFromBinaries(outDir, disposable, ConfigurationKind.JDK_ONLY);
+        return loadTestNamespaceAndBindingContextFromBinaries(outDir, disposable, ConfigurationKind.JDK_ONLY).first;
     }
 
     @NotNull
@@ -89,7 +90,11 @@ public final class LoadDescriptorUtil {
     }
 
     @NotNull
-    public static NamespaceDescriptor loadTestNamespaceFromBinaries(@NotNull File outDir, @NotNull Disposable disposable, @NotNull ConfigurationKind configurationKind) {
+    public static Pair<NamespaceDescriptor, BindingContext> loadTestNamespaceAndBindingContextFromBinaries(
+            @NotNull File outDir,
+            @NotNull Disposable disposable,
+            @NotNull ConfigurationKind configurationKind
+    ) {
         Disposer.dispose(disposable);
 
         CompilerConfiguration configuration = CompileCompilerDependenciesTest.compilerConfigurationForTests(
@@ -101,11 +106,11 @@ public final class LoadDescriptorUtil {
         NamespaceDescriptor namespaceDescriptor =
                 javaDescriptorResolver.resolveNamespace(TEST_PACKAGE_FQNAME, DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN);
         assert namespaceDescriptor != null;
-        return namespaceDescriptor;
+        return Pair.create(namespaceDescriptor, injector.getBindingTrace().getBindingContext());
     }
 
     @NotNull
-    public static NamespaceDescriptor compileJavaAndLoadTestNamespaceFromBinary(
+    public static Pair<NamespaceDescriptor, BindingContext> compileJavaAndLoadTestNamespaceAndBindingContextFromBinary(
             @NotNull Collection<File> javaFiles,
             @NotNull File outDir,
             @NotNull Disposable disposable,
@@ -113,7 +118,7 @@ public final class LoadDescriptorUtil {
     )
             throws IOException {
         compileJavaWithAnnotationsJar(javaFiles, outDir);
-        return loadTestNamespaceFromBinaries(outDir, disposable, configurationKind);
+        return loadTestNamespaceAndBindingContextFromBinaries(outDir, disposable, configurationKind);
     }
 
     private static void compileJavaWithAnnotationsJar(@NotNull Collection<File> javaFiles, @NotNull File outDir) throws IOException {

compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaCustomTest.java

@@ -16,21 +16,23 @@
 
 package org.jetbrains.jet.jvm.compiler;
 
-import com.google.common.base.Function;
+import com.intellij.openapi.util.Pair;
-import com.google.common.collect.Collections2;
+import com.intellij.util.Function;
+import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.ConfigurationKind;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.lazy.KotlinTestWithEnvironment;
 import org.jetbrains.jet.test.util.NamespaceComparator;
 
 import java.io.File;
 import java.util.Arrays;
-import java.util.Collection;
+import java.util.List;
 
-import static org.jetbrains.jet.jvm.compiler.LoadDescriptorUtil.compileJavaAndLoadTestNamespaceFromBinary;
+import static org.jetbrains.jet.jvm.compiler.LoadDescriptorUtil.compileJavaAndLoadTestNamespaceAndBindingContextFromBinary;
 
 /**
  * @author Pavel Talanov
@@ -48,17 +50,23 @@ public final class LoadJavaCustomTest extends KotlinTestWithEnvironment {
     }
 
     private void doTest(@NotNull String expectedFileName, @NotNull String... javaFileNames) throws Exception {
-        Collection<File> files = Collections2.transform(Arrays.asList(javaFileNames), new Function<String, File>() {
+        List<File> files = ContainerUtil.map(Arrays.asList(javaFileNames), new Function<String, File>() {
             @Override
-            public File apply(String s) {
+            public File fun(String s) {
                 return new File(s);
             }
         });
+        files.add(ExpectedLoadErrorsUtil.ANNOTATION_SOURCE_FILE);
         File expected = new File(expectedFileName);
         File tmpDir = JetTestUtils.tmpDir(expected.getName());
-        NamespaceDescriptor javaNamespaceDescriptor = compileJavaAndLoadTestNamespaceFromBinary(files, tmpDir, getTestRootDisposable(), ConfigurationKind.JDK_ONLY);
+
+        Pair<NamespaceDescriptor, BindingContext> javaNamespaceAndBindingContext
+                = compileJavaAndLoadTestNamespaceAndBindingContextFromBinary(files, tmpDir, getTestRootDisposable(),
+                                                                             ConfigurationKind.JDK_ONLY);
+        NamespaceDescriptor javaNamespace = javaNamespaceAndBindingContext.first;
         //NOTE: comparing namespace to file (hack)
-        NamespaceComparator.compareNamespaces(javaNamespaceDescriptor, javaNamespaceDescriptor, NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT, expected);
+        NamespaceComparator.compareNamespaces(javaNamespace, javaNamespace, NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT, expected);
+        ExpectedLoadErrorsUtil.checkForLoadErrors(javaNamespace, javaNamespaceAndBindingContext.second);
     }
 
     public void testPackageLocalVisibility() throws Exception {

compiler/tests/org/jetbrains/jet/jvm/compiler/annotation/ExpectLoadError.java

@@ -0,0 +1,12 @@
+package org.jetbrains.jet.jvm.compiler.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.CLASS)
+@Target({ElementType.METHOD, ElementType.FIELD, ElementType.CONSTRUCTOR})
+public @interface ExpectLoadError {
+    String value();
+}

compiler/tests/org/jetbrains/jet/test/util/NamespaceComparator.java

@@ -21,9 +21,12 @@ import com.google.common.base.Predicates;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 import com.google.common.collect.Sets;
+import com.intellij.openapi.util.Condition;
 import com.intellij.openapi.util.io.FileUtil;
+import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.codegen.PropertyCodegen;
+import org.jetbrains.jet.jvm.compiler.ExpectedLoadErrorsUtil;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
@@ -382,14 +385,28 @@ public class NamespaceComparator {
             }
         }
 
+        // We want to skip @ExpectLoadErrors annotations when comparing
+        private static List<AnnotationDescriptor> filterAnnotations(List<AnnotationDescriptor> annotations) {
+            return ContainerUtil.filter(annotations, new Condition<AnnotationDescriptor>() {
+                @Override
+                public boolean value(AnnotationDescriptor annotation) {
+                    ClassDescriptor annotationClass = (ClassDescriptor) annotation.getType().getConstructor().getDeclarationDescriptor();
+                    assert annotationClass != null;
+
+                    return !DescriptorUtils.getFQName(annotationClass).getFqName().equals(ExpectedLoadErrorsUtil.ANNOTATION_CLASS_NAME);
+                }
+            });
+        }
+
         public void serialize(FunctionDescriptor fun) {
             serialize(fun.getVisibility());
             sb.append(" ");
             serialize(fun.getModality());
             sb.append(" ");
 
-            if (!fun.getAnnotations().isEmpty()) {
+            List<AnnotationDescriptor> annotations = filterAnnotations(fun.getAnnotations());
-                new Serializer(sb).serializeSeparated(fun.getAnnotations(), " ");
+            if (!annotations.isEmpty()) {
+                new Serializer(sb).serializeSeparated(annotations, " ");
                 sb.append(" ");
             }
 
@@ -464,8 +481,9 @@ public class NamespaceComparator {
             serialize(prop.getModality());
             sb.append(" ");
 
-            if (!prop.getAnnotations().isEmpty()) {
+            List<AnnotationDescriptor> annotations = filterAnnotations(prop.getAnnotations());
-                new Serializer(sb).serializeSeparated(prop.getAnnotations(), " ");
+            if (!annotations.isEmpty()) {
+                new Serializer(sb).serializeSeparated(annotations, " ");
                 sb.append(" ");
             }