do not use deprecated findClass() method

java/java-impl/src/com/intellij/codeInsight/template/macro/AnnotatedMacro.java

@@ -19,6 +19,7 @@ package com.intellij.codeInsight.template.macro;
 import com.intellij.codeInsight.lookup.LookupElement;
 import com.intellij.codeInsight.lookup.LookupElementBuilder;
 import com.intellij.codeInsight.template.*;
+import com.intellij.openapi.project.Project;
 import com.intellij.psi.JavaPsiFacade;
 import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiManager;
@@ -28,17 +29,14 @@ import com.intellij.psi.search.searches.AnnotatedMembersSearch;
 import com.intellij.util.Query;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 import java.util.LinkedHashSet;
 import java.util.Set;
 
 /**
-* Created by IntelliJ IDEA.
-* User: Maxim.Mossienko
-* Date: 11.06.2009
-* Time: 0:20:54
-* To change this template use File | Settings | File Templates.
-*/
+ * @author Maxim.Mossienko
+ */
 public class AnnotatedMacro implements Macro {
 
   @NonNls
@@ -55,7 +53,8 @@ public class AnnotatedMacro implements Macro {
     return "";
   }
 
-  private Query<PsiMember> findAnnotated(ExpressionContext context, Expression[] params) {
+  @Nullable
+  private static Query<PsiMember> findAnnotated(ExpressionContext context, Expression[] params) {
     if (params == null || params.length == 0) return null;
     PsiManager instance = PsiManager.getInstance(context.getProject());
 
@@ -94,8 +93,10 @@ public class AnnotatedMacro implements Macro {
       Set<LookupElement> set = new LinkedHashSet<LookupElement>();
       final String secondParamValue = params.length > 1 ? params[1].calculateResult(context).toString() : null;
       final boolean isShortName = secondParamValue != null && !Boolean.valueOf(secondParamValue);
-      final PsiClass findInClass =
-        secondParamValue != null ? JavaPsiFacade.getInstance(context.getProject()).findClass(secondParamValue) : null;
+      final Project project = context.getProject();
+      final PsiClass findInClass = secondParamValue != null
+                                   ? JavaPsiFacade.getInstance(project).findClass(secondParamValue, GlobalSearchScope.allScope(project))
+                                   : null;
 
       for (PsiMember object : query.findAll()) {
         if (findInClass != null && !object.getContainingClass().equals(findInClass)) continue;

java/java-impl/src/com/intellij/refactoring/introduceparameterobject/usageInfo/MergeMethodArguments.java

@@ -20,6 +20,7 @@ import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.*;
 import com.intellij.psi.codeStyle.JavaCodeStyleManager;
 import com.intellij.psi.impl.source.PsiImmediateClassType;
+import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.psi.util.TypeConversionUtil;
 import com.intellij.refactoring.changeSignature.ChangeSignatureProcessor;
 import com.intellij.refactoring.changeSignature.ParameterInfoImpl;
@@ -71,7 +72,7 @@ public class MergeMethodArguments extends FixableUsageInfo {
       psiClass = myContainingClass.findInnerClassByName(className, false);
     }
     else {
-      psiClass = psiFacade.findClass(StringUtil.getQualifiedName(packageName, className));
+      psiClass = psiFacade.findClass(StringUtil.getQualifiedName(packageName, className), GlobalSearchScope.allScope(getProject()));
     }
     PsiSubstitutor subst = PsiSubstitutor.EMPTY;
     if (deepestSuperMethod != null) {

java/java-impl/src/com/intellij/refactoring/migration/MigrationUtil.java

@@ -34,6 +34,9 @@ import java.util.ArrayList;
 public class MigrationUtil {
   private static final Logger LOG = Logger.getInstance("#com.intellij.refactoring.migration.MigrationUtil");
 
+  private MigrationUtil() {
+  }
+
   public static UsageInfo[] findPackageUsages(PsiManager manager, PsiMigration migration, String qName) {
     PsiPackage aPackage = findOrCreatePackage(manager, migration, qName);
 
@@ -129,7 +132,7 @@ public class MigrationUtil {
   }
 
   static PsiClass findOrCreateClass(PsiManager manager, final PsiMigration migration, final String qName) {
-    PsiClass aClass = JavaPsiFacade.getInstance(manager.getProject()).findClass(qName);
+    PsiClass aClass = JavaPsiFacade.getInstance(manager.getProject()).findClass(qName, GlobalSearchScope.allScope(manager.getProject()));
     if (aClass == null) {
       aClass = ApplicationManager.getApplication().runWriteAction(new Computable<PsiClass>() {
         public PsiClass compute() {

java/java-impl/src/com/intellij/refactoring/wrapreturnvalue/WrapReturnValueProcessor.java

@@ -26,6 +26,7 @@ import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.*;
 import com.intellij.psi.codeStyle.CodeStyleManager;
 import com.intellij.psi.codeStyle.JavaCodeStyleManager;
+import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.psi.search.searches.OverridingMethodsSearch;
 import com.intellij.psi.search.searches.ReferencesSearch;
 import com.intellij.psi.util.PsiTreeUtil;
@@ -97,7 +98,7 @@ public class WrapReturnValueProcessor extends FixableUsagesRefactoringProcessor
   }
 
   private String calculateUnwrapMethodName() {
-    final PsiClass existingClass = JavaPsiFacade.getInstance(myProject).findClass(myQualifiedName);
+    final PsiClass existingClass = JavaPsiFacade.getInstance(myProject).findClass(myQualifiedName, GlobalSearchScope.allScope(myProject));
     if (existingClass != null) {
       if (TypeConversionUtil.isPrimitiveWrapper(myQualifiedName)) {
         final PsiPrimitiveType unboxedType =
@@ -156,7 +157,7 @@ public class WrapReturnValueProcessor extends FixableUsagesRefactoringProcessor
   @Override
   protected boolean preprocessUsages(final Ref<UsageInfo[]> refUsages) {
     MultiMap<PsiElement, String> conflicts = new MultiMap<PsiElement, String>();
-    final PsiClass existingClass = JavaPsiFacade.getInstance(myProject).findClass(myQualifiedName);
+    final PsiClass existingClass = JavaPsiFacade.getInstance(myProject).findClass(myQualifiedName, GlobalSearchScope.allScope(myProject));
     if (myUseExistingClass) {
       if (existingClass == null) {
         conflicts.putValue(existingClass, RefactorJBundle.message("could.not.find.selected.wrapping.class"));

java/java-tests/testSrc/com/intellij/refactoring/InlineSuperClassTest.java

@@ -9,6 +9,7 @@ import com.intellij.openapi.projectRoots.Sdk;
 import com.intellij.openapi.projectRoots.impl.JavaSdkImpl;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.PsiClass;
+import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.refactoring.inlineSuperClass.InlineSuperClassRefactoringProcessor;
 
 public class InlineSuperClassTest extends MultiFileTestCase {
@@ -33,14 +34,14 @@ public class InlineSuperClassTest extends MultiFileTestCase {
     try {
       doTest(new PerformAction() {
         public void performAction(final VirtualFile rootDir, final VirtualFile rootAfter) throws Exception {
-          PsiClass aClass = myJavaFacade.findClass("Test");
+          PsiClass aClass = myJavaFacade.findClass("Test", GlobalSearchScope.allScope(myProject));
 
-          if (aClass == null) aClass = myJavaFacade.findClass("p.Test");
+          if (aClass == null) aClass = myJavaFacade.findClass("p.Test", GlobalSearchScope.allScope(myProject));
           assertNotNull("Class Test not found", aClass);
 
-          PsiClass superClass = myJavaFacade.findClass("Super");
+          PsiClass superClass = myJavaFacade.findClass("Super", GlobalSearchScope.allScope(myProject));
 
-          if (superClass == null) superClass = myJavaFacade.findClass("p1.Super");
+          if (superClass == null) superClass = myJavaFacade.findClass("p1.Super", GlobalSearchScope.allScope(myProject));
           assertNotNull("Class Super not found", superClass);
 
           new InlineSuperClassRefactoringProcessor(getProject(), superClass, aClass).run();
@@ -162,11 +163,13 @@ public class InlineSuperClassTest extends MultiFileTestCase {
   public void testMultipleSubclasses() throws Exception {
     doTest(new PerformAction() {
       public void performAction(final VirtualFile rootDir, final VirtualFile rootAfter) throws Exception {
-        PsiClass superClass = myJavaFacade.findClass("Super");
-        if (superClass == null) superClass = myJavaFacade.findClass("p1.Super");
+        PsiClass superClass = myJavaFacade.findClass("Super", GlobalSearchScope.allScope(myProject));
+        if (superClass == null) superClass = myJavaFacade.findClass("p1.Super", GlobalSearchScope.allScope(myProject));
         assertNotNull("Class Super not found", superClass);
-        new InlineSuperClassRefactoringProcessor(getProject(), superClass, myJavaFacade.findClass("Test"), myJavaFacade.findClass("Test1")).run();
+        new InlineSuperClassRefactoringProcessor(getProject(), superClass,
+                                                 myJavaFacade.findClass("Test", GlobalSearchScope.allScope(myProject)),
+                                                 myJavaFacade.findClass("Test1", GlobalSearchScope.allScope(myProject))).run();
       }
     });
   }
-}
+}

java/java-tests/testSrc/com/intellij/refactoring/IntroduceVariableMultifileTest.java

@@ -9,6 +9,7 @@ import com.intellij.pom.java.LanguageLevel;
 import com.intellij.psi.JavaPsiFacade;
 import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiFile;
+import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.refactoring.introduceVariable.IntroduceVariableBase;
 
 /**
@@ -80,7 +81,7 @@ public class IntroduceVariableMultifileTest extends MultiFileTestCase {
     return new PerformAction() {
       public void performAction(VirtualFile vroot, VirtualFile rootAfter) {
         final JavaPsiFacade psiManager = getJavaFacade();
-        final PsiClass aClass = psiManager.findClass(className);
+        final PsiClass aClass = psiManager.findClass(className, GlobalSearchScope.allScope(myProject));
         assertTrue(aClass != null);
         final PsiFile containingFile = aClass.getContainingFile();
         final VirtualFile virtualFile = containingFile.getVirtualFile();

java/java-tests/testSrc/com/intellij/refactoring/PushDownMultifileTest.java

@@ -11,6 +11,7 @@ import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiField;
 import com.intellij.psi.PsiMethod;
+import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.refactoring.memberPushDown.PushDownProcessor;
 import com.intellij.refactoring.util.DocCommentPolicy;
 import com.intellij.refactoring.util.classMembers.MemberInfo;
@@ -38,10 +39,10 @@ public class PushDownMultifileTest extends MultiFileTestCase {
     try {
       doTest(new PerformAction() {
         public void performAction(final VirtualFile rootDir, final VirtualFile rootAfter) throws Exception {
-          final PsiClass srcClass = myJavaFacade.findClass("a.A");
+          final PsiClass srcClass = myJavaFacade.findClass("a.A", GlobalSearchScope.allScope(myProject));
           assertTrue("Source class not found", srcClass != null);
 
-          final PsiClass targetClass = myJavaFacade.findClass("b.B");
+          final PsiClass targetClass = myJavaFacade.findClass("b.B", GlobalSearchScope.allScope(myProject));
           assertTrue("Target class not found", targetClass != null);
 
           final PsiMethod[] methods = srcClass.getMethods();
@@ -85,10 +86,10 @@ public class PushDownMultifileTest extends MultiFileTestCase {
     try {
       doTest(new PerformAction() {
         public void performAction(final VirtualFile rootDir, final VirtualFile rootAfter) throws Exception {
-          final PsiClass srcClass = myJavaFacade.findClass("a.A");
+          final PsiClass srcClass = myJavaFacade.findClass("a.A", GlobalSearchScope.allScope(myProject));
           assertTrue("Source class not found", srcClass != null);
 
-          final PsiClass targetClass = myJavaFacade.findClass("b.B");
+          final PsiClass targetClass = myJavaFacade.findClass("b.B", GlobalSearchScope.allScope(myProject));
           assertTrue("Target class not found", targetClass != null);
 
           final PsiField[] fields = srcClass.getFields();
@@ -112,4 +113,4 @@ public class PushDownMultifileTest extends MultiFileTestCase {
     }
     fail("Conflict was not detected");
   }
-}
+}

java/java-tests/testSrc/com/intellij/refactoring/TurnRefsToSuperTest.java

@@ -4,6 +4,7 @@ import com.intellij.JavaTestUtil;
 import com.intellij.openapi.fileEditor.FileDocumentManager;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.PsiClass;
+import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.refactoring.turnRefsToSuper.TurnRefsToSuperProcessor;
 import org.jetbrains.annotations.NonNls;
 
@@ -138,12 +139,12 @@ public class TurnRefsToSuperTest extends MultiFileTestCase {
   }
 
   private void performAction(final String className, final String superClassName, boolean replaceInstanceOf) {
-    final PsiClass aClass = myJavaFacade.findClass(className);
+    final PsiClass aClass = myJavaFacade.findClass(className, GlobalSearchScope.allScope(myProject));
     assertNotNull("Class " + className + " not found", aClass);
-    PsiClass superClass = myJavaFacade.findClass(superClassName);
+    PsiClass superClass = myJavaFacade.findClass(superClassName, GlobalSearchScope.allScope(myProject));
     assertNotNull("Class " + superClassName + " not found", superClass);
 
     new TurnRefsToSuperProcessor(myProject, aClass, superClass, replaceInstanceOf).run();
     FileDocumentManager.getInstance().saveAllDocuments();
   }
-}
+}

java/java-tests/testSrc/com/intellij/refactoring/TypeCookTest.java

@@ -8,6 +8,7 @@ import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.vfs.LocalFileSystem;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.PsiClass;
+import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.refactoring.typeCook.Settings;
 import com.intellij.refactoring.typeCook.deductive.builder.ReductionSystem;
 import com.intellij.refactoring.typeCook.deductive.builder.SystemBuilder;
@@ -663,7 +664,7 @@ public class TypeCookTest extends MultiFileTestCase {
   }
 
   private void performAction(String className, String rootDir, final boolean cookObjects) throws Exception {
-    PsiClass aClass = myJavaFacade.findClass(className);
+    PsiClass aClass = myJavaFacade.findClass(className, GlobalSearchScope.allScope(myProject));
 
     assertNotNull("Class " + className + " not found", aClass);
 
@@ -736,8 +737,12 @@ public class TypeCookTest extends MultiFileTestCase {
     PrintWriter writer;
     if (!patternFile.exists()) {
       writer = new PrintWriter(new FileOutputStream(patternFile));
-      writer.print(itemRepr);
-      writer.close();
+      try {
+        writer.print(itemRepr);
+      }
+      finally {
+        writer.close();
+      }
 
       System.out.println("Pattern not found, file " + patternName + " created.");
 
@@ -747,10 +752,14 @@ public class TypeCookTest extends MultiFileTestCase {
     File graFile = new File(FileUtil.getTempDirectory() + File.separator + rootDir + File.separator + itemName);
 
     writer = new PrintWriter(new FileOutputStream(graFile));
+    try {
+      writer.print(itemRepr);
+    }
+    finally {
+      writer.close();
+    }
 
-    writer.print(itemRepr);
 
-    writer.close();
 
     LocalFileSystem.getInstance().refreshAndFindFileByIoFile(graFile);
     FileDocumentManager.getInstance().saveAllDocuments();

plugins/devkit/testSources/codeInsight/CreateClassFixTest.java

@@ -23,8 +23,10 @@ package org.jetbrains.idea.devkit.codeInsight;
 import com.intellij.codeInsight.daemon.QuickFixBundle;
 import com.intellij.codeInsight.intention.IntentionAction;
 import com.intellij.openapi.application.PluginPathManager;
+import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Comparing;
 import com.intellij.psi.JavaPsiFacade;
+import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.testFramework.builders.JavaModuleFixtureBuilder;
 import com.intellij.testFramework.fixtures.CodeInsightTestFixture;
 import com.intellij.testFramework.fixtures.IdeaProjectTestFixture;
@@ -55,7 +57,7 @@ public class CreateClassFixTest {
     myFixture.setUp();
   }
 
-  private String getSourceRoot() {
+  private static String getSourceRoot() {
     return "codeInsight";
   }
 
@@ -77,7 +79,8 @@ public class CreateClassFixTest {
     }
     Assert.assertNotNull(resultAction);
     myFixture.launchAction(resultAction);
-    Assert.assertNotNull(JavaPsiFacade.getInstance(myFixture.getProject()).findClass(testName));
+    final Project project = myFixture.getProject();
+    Assert.assertNotNull(JavaPsiFacade.getInstance(project).findClass(testName, GlobalSearchScope.allScope(project)));
   }
 
 
@@ -86,4 +89,4 @@ public class CreateClassFixTest {
     myFixture.tearDown();
     myFixture = null;
   }
-}
+}

plugins/groovy/test/org/jetbrains/plugins/groovy/refactoring/copy/GroovyCopyClassTest.java

@@ -18,6 +18,7 @@ package org.jetbrains.plugins.groovy.refactoring.copy;
 import com.intellij.openapi.application.Result;
 import com.intellij.openapi.command.WriteCommandAction;
 import com.intellij.psi.PsiClass;
+import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.refactoring.copy.CopyClassesHandler;
 import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase;
 import org.jetbrains.plugins.groovy.util.TestUtils;
@@ -37,7 +38,7 @@ public class GroovyCopyClassTest extends LightCodeInsightFixtureTestCase {
     myFixture.addClass("package foo; public class Bar {}");
     myFixture.addClass("package bar; public class Bar {}");
 
-    final PsiClass srcClass = myFixture.getJavaFacade().findClass("foo." + testName);
+    final PsiClass srcClass = myFixture.getJavaFacade().findClass("foo." + testName, GlobalSearchScope.allScope(getProject()));
     assertTrue(CopyClassesHandler.canCopyClass(srcClass));
     new WriteCommandAction(getProject()) {
       protected void run(Result result) throws Throwable {
@@ -52,7 +53,8 @@ public class GroovyCopyClassTest extends LightCodeInsightFixtureTestCase {
     final String testName = getTestName(false);
     myFixture.copyFileToProject(testName + ".groovy", "/foo/" + testName + ".groovy");
 
-    assertFalse(CopyClassesHandler.canCopyClass(myFixture.getJavaFacade().findClass("foo." + testName)));
+    assertFalse(
+      CopyClassesHandler.canCopyClass(myFixture.getJavaFacade().findClass("foo." + testName, GlobalSearchScope.allScope(getProject()))));
   }
 
 }

plugins/groovy/test/org/jetbrains/plugins/groovy/refactoring/move/GroovyMoveClassTest.java

@@ -27,6 +27,7 @@ import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.openapi.vfs.VirtualFileManager;
 import com.intellij.psi.*;
 import com.intellij.psi.impl.source.PostprocessReformattingAspect;
+import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.refactoring.PackageWrapper;
 import com.intellij.refactoring.move.moveClassesOrPackages.MoveClassesOrPackagesProcessor;
 import com.intellij.refactoring.move.moveClassesOrPackages.SingleSourceRootMoveDestination;
@@ -124,7 +125,7 @@ public class GroovyMoveClassTest extends LightCodeInsightFixtureTestCase {
     final PsiClass[] classes = new PsiClass[classNames.length];
     for (int i = 0; i < classes.length; i++) {
       String className = classNames[i];
-      classes[i] = JavaPsiFacade.getInstance(getProject()).findClass(className);
+      classes[i] = JavaPsiFacade.getInstance(getProject()).findClass(className, GlobalSearchScope.allScope(getProject()));
       assertNotNull("Class " + className + " not found", classes[i]);
     }
 
@@ -216,16 +217,19 @@ public class GroovyMoveClassTest extends LightCodeInsightFixtureTestCase {
   private static byte[] contentsToByteArray(File f) throws IOException {
     int b;
     final FileReader fileReader = new FileReader(f);
-    ArrayList<Byte> bytes = new ArrayList<Byte>();
-    while ((b = fileReader.read()) >= 0) {
-      bytes.add((byte)b);
+    try {
+      ArrayList<Byte> bytes = new ArrayList<Byte>();
+      while ((b = fileReader.read()) >= 0) {
+        bytes.add((byte)b);
+      }
+      final byte[] res = new byte[bytes.size()];
+      for (int i = 0; i < res.length; i++) {
+        res[i] = bytes.get(i);
+      }
+      return res;
     }
-    final byte[] res = new byte[bytes.size()];
-    for (int i = 0; i < res.length; i++) {
-      res[i] = bytes.get(i);
+    finally {
+      fileReader.close();
     }
-    return res;
   }
-
-
 }

plugins/testng/testSources/com/theoryinpractice/testng/configuration/ConfigurationsTest.java

@@ -33,6 +33,7 @@ import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.psi.JavaPsiFacade;
 import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiMethod;
+import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.refactoring.RefactoringFactory;
 import com.intellij.refactoring.RenameRefactoring;
 import com.intellij.testFramework.builders.JavaModuleFixtureBuilder;
@@ -185,19 +186,19 @@ public class ConfigurationsTest {
     Assert.assertTrue(t.isConfigurationByLocation(runConfiguration, new PsiLocation(project, psiClass)));
   }
 
-  private PsiClass findTestClass(final Project project) {
-    final PsiClass psiClass = JavaPsiFacade.getInstance(project).findClass("Testt");
+  private static PsiClass findTestClass(final Project project) {
+    final PsiClass psiClass = JavaPsiFacade.getInstance(project).findClass("Testt", GlobalSearchScope.allScope(project));
     assert psiClass != null;
     return psiClass;
   }
 
-  private PsiMethod findNotATestMethod(final PsiClass psiClass) {
+  private static PsiMethod findNotATestMethod(final PsiClass psiClass) {
     final PsiMethod[] notATestMethods = psiClass.findMethodsByName("notATest", false);
     assert notATestMethods.length == 1;
     return notATestMethods[0];
   }
 
-  private TestNGConfiguration createConfiguration(final Project project) {
+  private static TestNGConfiguration createConfiguration(final Project project) {
     final RunManagerEx manager = RunManagerEx.getInstanceEx(project);
     final RunnerAndConfigurationSettings settings =
       manager.createRunConfiguration("testt", TestNGConfigurationType.getInstance().getConfigurationFactories()[0]);