Remove RuntimeHandleClassesMode

There were two usages of RuntimeHandleClassesMode.REPORT_ERROR: first in tests,
where it never occurred, second in JavaClassResolver, where it's now inlined

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PsiClassFinder.java

@@ -23,13 +23,8 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 
 public interface PsiClassFinder {
-    enum RuntimeClassesHandleMode {
-        REPORT_ERROR,
-        IGNORE,
-    }
-
     @Nullable
-    PsiClass findPsiClass(@NotNull FqName fqName, @NotNull RuntimeClassesHandleMode runtimeClassesHandleMode);
+    PsiClass findPsiClass(@NotNull FqName fqName);
 
     @Nullable
     PsiPackage findPsiPackage(@NotNull FqName fqName);

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PsiClassFinderImpl.java

@@ -16,29 +16,22 @@
 
 package org.jetbrains.jet.lang.resolve.java;
 
-import com.intellij.openapi.application.ApplicationManager;
-import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Comparing;
 import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.psi.PsiAnnotation;
 import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiPackage;
 import com.intellij.psi.search.DelegatingGlobalSearchScope;
 import com.intellij.psi.search.GlobalSearchScope;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
 import org.jetbrains.jet.lang.resolve.name.FqName;
-import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.plugin.JetFileType;
 
 import javax.annotation.PostConstruct;
 import javax.inject.Inject;
 
 public class PsiClassFinderImpl implements PsiClassFinder {
-    private static final Logger LOG = Logger.getInstance(PsiClassFinderImpl.class);
-
     @NotNull
     private Project project;
 
@@ -78,10 +71,9 @@ public class PsiClassFinderImpl implements PsiClassFinder {
         javaFacade = new JavaPsiFacadeKotlinHacks(project);
     }
 
-
     @Override
     @Nullable
-    public PsiClass findPsiClass(@NotNull FqName qualifiedName, @NotNull RuntimeClassesHandleMode runtimeClassesHandleMode) {
+    public PsiClass findPsiClass(@NotNull FqName qualifiedName) {
         PsiClass original = javaFacade.findClass(qualifiedName.asString(), javaSearchScope);
 
         if (original != null) {
@@ -96,31 +88,6 @@ public class PsiClassFinderImpl implements PsiClassFinder {
             throw new IllegalStateException("JetJavaMirrorMaker is not possible in resolve.java, resolving: " + qualifiedName);
         }
 
-        if (original == null) {
-            return null;
-        }
-
-        if (KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME.equals(qualifiedName.parent())) {
-            PsiAnnotation assertInvisibleAnnotation = JavaAnnotationResolver.findOwnAnnotation(
-                    original, JvmAnnotationNames.ASSERT_INVISIBLE_IN_RESOLVER.getFqName().asString());
-
-            if (assertInvisibleAnnotation != null) {
-                switch (runtimeClassesHandleMode) {
-                    case IGNORE:
-                        break;
-                    case REPORT_ERROR:
-                        if (ApplicationManager.getApplication().isInternal()) {
-                            LOG.error("classpath is configured incorrectly:" +
-                                      " class " + qualifiedName + " from runtime must not be loaded by compiler");
-                        }
-                        break;
-                    default:
-                        throw new IllegalStateException("unknown parameter value: " + runtimeClassesHandleMode);
-                }
-                return null;
-            }
-        }
-
         return original;
     }
 

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/AnnotationDescriptorDeserializer.java

@@ -123,7 +123,7 @@ public class AnnotationDescriptorDeserializer implements AnnotationDeserializer
         if (fileForKotlinFile != null) {
             return fileForKotlinFile;
         }
-        PsiClass psiClass = psiClassFinder.findPsiClass(fqName, PsiClassFinder.RuntimeClassesHandleMode.IGNORE /* TODO: ?! */);
+        PsiClass psiClass = psiClassFinder.findPsiClass(fqName);
         if (psiClass == null) {
             throw new IllegalStateException("Psi class is not found for class: " + descriptor);
         }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java

@@ -18,8 +18,11 @@ package org.jetbrains.jet.lang.resolve.java.resolver;
 
 import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;
+import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.psi.PsiAnnotation;
 import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiMethod;
 import com.intellij.psi.PsiModifier;
@@ -60,6 +63,7 @@ import static org.jetbrains.jet.lang.resolve.DescriptorUtils.getClassObjectName;
 import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.INCLUDE_KOTLIN_SOURCES;
 
 public final class JavaClassResolver {
+    private static final Logger LOG = Logger.getInstance(JavaClassResolver.class);
 
     // NOTE: this complexity is introduced because class descriptors do not always have valid fqnames (class objects)
     @NotNull
@@ -233,12 +237,25 @@ public final class JavaClassResolver {
             }
         }
 
-        PsiClass psiClass = psiClassFinder.findPsiClass(qualifiedName, PsiClassFinder.RuntimeClassesHandleMode.REPORT_ERROR);
+        PsiClass psiClass = psiClassFinder.findPsiClass(qualifiedName);
         if (psiClass == null) {
             cacheNegativeValue(javaClassToKotlinFqName(qualifiedName));
             return null;
         }
 
+        if (KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME.equals(qualifiedName.parent())) {
+            PsiAnnotation assertInvisibleAnnotation = JavaAnnotationResolver.findOwnAnnotation(
+                    psiClass, JvmAnnotationNames.ASSERT_INVISIBLE_IN_RESOLVER.getFqName().asString());
+
+            if (assertInvisibleAnnotation != null) {
+                if (ApplicationManager.getApplication().isInternal()) {
+                    LOG.error("classpath is configured incorrectly:" +
+                              " class " + qualifiedName + " from runtime must not be loaded by compiler");
+                }
+                return null;
+            }
+        }
+
         // Class may have been resolved previously by different Java resolver instance, and we are reusing its trace
         ClassDescriptor alreadyResolved = trace.get(BindingContext.CLASS, psiClass);
         if (alreadyResolved != null) {

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaNamespaceResolver.java

@@ -181,7 +181,7 @@ public final class JavaNamespaceResolver {
             return new JavaPackageScope(namespaceDescriptor, psiPackage, fqName, javaDescriptorResolver);
         }
 
-        PsiClass psiClass = psiClassFinder.findPsiClass(fqName, PsiClassFinder.RuntimeClassesHandleMode.IGNORE);
+        PsiClass psiClass = psiClassFinder.findPsiClass(fqName);
         if (psiClass == null) {
             return null;
         }

compiler/tests/org/jetbrains/jet/resolve/JetExpectedResolveDataUtil.java

@@ -29,7 +29,6 @@ import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
 import org.jetbrains.jet.lang.resolve.calls.context.ExpressionPosition;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall;
 import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResults;
-import org.jetbrains.jet.lang.resolve.java.PsiClassFinder;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
@@ -115,7 +114,7 @@ public class JetExpectedResolveDataUtil {
     @NotNull
     private static PsiClass findClass(String qualifiedName, Project project) {
         InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(project, new BindingTraceContext());
-        PsiClass psiClass = injector.getPsiClassFinder().findPsiClass(new FqName(qualifiedName), PsiClassFinder.RuntimeClassesHandleMode.REPORT_ERROR);
+        PsiClass psiClass = injector.getPsiClassFinder().findPsiClass(new FqName(qualifiedName));
         Assert.assertNotNull("Class wasn't found: " + qualifiedName, psiClass);
         return psiClass;
     }