diff --git a/java/java-indexing-api/src/com/intellij/psi/search/searches/MethodReferencesSearch.java b/java/java-indexing-api/src/com/intellij/psi/search/searches/MethodReferencesSearch.java
index 8a0b5e3a8144..75f3b38f16ff 100644
--- a/java/java-indexing-api/src/com/intellij/psi/search/searches/MethodReferencesSearch.java
+++ b/java/java-indexing-api/src/com/intellij/psi/search/searches/MethodReferencesSearch.java
@@ -35,6 +35,7 @@ public class MethodReferencesSearch extends ExtensibleQueryFactory<PsiReference,
 
   public static class SearchParameters {
     private final PsiMethod myMethod;
+    private final Project myProject;
     private final SearchScope myScope;
     private final boolean myStrictSignatureSearch;
     private final SearchRequestCollector myOptimizer;
@@ -46,12 +47,18 @@ public class MethodReferencesSearch extends ExtensibleQueryFactory<PsiReference,
       myStrictSignatureSearch = strictSignatureSearch;
       isSharedOptimizer = optimizer != null;
       myOptimizer = optimizer != null ? optimizer : new SearchRequestCollector(new SearchSession());
+      myProject = PsiUtilCore.getProjectInReadAction(method);
     }
 
     public SearchParameters(@NotNull PsiMethod method, @NotNull SearchScope scope, final boolean strict) {
       this(method, scope, strict, null);
     }
 
+    @NotNull
+    public Project getProject() {
+      return myProject;
+    }
+
     @NotNull
     public PsiMethod getMethod() {
       return myMethod;
diff --git a/java/java-indexing-impl/src/com/intellij/psi/impl/search/ConstructorReferencesSearchHelper.java b/java/java-indexing-impl/src/com/intellij/psi/impl/search/ConstructorReferencesSearchHelper.java
index b516b8a8386e..a7babb2fa461 100644
--- a/java/java-indexing-impl/src/com/intellij/psi/impl/search/ConstructorReferencesSearchHelper.java
+++ b/java/java-indexing-impl/src/com/intellij/psi/impl/search/ConstructorReferencesSearchHelper.java
@@ -16,6 +16,7 @@
 package com.intellij.psi.impl.search;
 
 import com.intellij.openapi.project.DumbService;
+import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Computable;
 import com.intellij.openapi.util.TextRange;
 import com.intellij.pom.java.LanguageLevel;
@@ -41,17 +42,25 @@ public class ConstructorReferencesSearchHelper {
     myManager = manager;
   }
 
+  /*
+   * Project is passed around explicitly to avoid invoking PsiElement.getProject each time we need it. There are two reasons:
+   * 1. Performance. getProject traverses AST upwards
+   * 2. Exception avoidance. Project is needed outside of read action (to run it via DumbService in the first place),
+   *    and so getProject would fail with an assertion that read action is required but not present.
+   */
   public boolean processConstructorReferences(@NotNull final Processor<PsiReference> processor,
                                               @NotNull final PsiMethod constructor,
                                               @NotNull final PsiClass containingClass,
                                               @NotNull final SearchScope searchScope,
+                                              @NotNull final Project project,
                                               boolean ignoreAccessScope,
                                               final boolean isStrictSignatureSearch,
                                               @NotNull SearchRequestCollector collector) {
     final boolean[] constructorCanBeCalledImplicitly = new boolean[1];
     final boolean[] isEnum = new boolean[1];
     final boolean[] isUnder18 = new boolean[1];
-    DumbService.getInstance(constructor.getProject()).runReadActionInSmartMode(new Runnable() {
+
+    DumbService.getInstance(project).runReadActionInSmartMode(new Runnable() {
       @Override
       public void run() {
         constructorCanBeCalledImplicitly[0] = constructor.getParameterList().getParametersCount() == 0;
@@ -61,7 +70,7 @@ public class ConstructorReferencesSearchHelper {
     });
 
     if (isEnum[0]) {
-      if (!processEnumReferences(processor, constructor, containingClass)) return false;
+      if (!processEnumReferences(processor, constructor, project, containingClass)) return false;
     }
 
     // search usages like "new XXX(..)"
@@ -93,14 +102,14 @@ public class ConstructorReferencesSearchHelper {
 
     ReferencesSearch.searchOptimized(containingClass, searchScope, ignoreAccessScope, collector, true, processor1);
     if (isUnder18[0]) {
-      if (!process18MethodPointers(processor, constructor, containingClass, searchScope)) return false;
+      if (!process18MethodPointers(processor, constructor, project, containingClass, searchScope)) return false;
     }
 
     // search usages like "this(..)"
-    if (!DumbService.getInstance(constructor.getProject()).runReadActionInSmartMode(new Computable<Boolean>() {
+    if (!DumbService.getInstance(project).runReadActionInSmartMode(new Computable<Boolean>() {
       @Override
       public Boolean compute() {
-        return processSuperOrThis(containingClass, constructor, constructorCanBeCalledImplicitly[0], searchScope, isStrictSignatureSearch,
+        return processSuperOrThis(containingClass, constructor, constructorCanBeCalledImplicitly[0], searchScope, project, isStrictSignatureSearch,
                                   PsiKeyword.THIS, processor);
       }
     })) {
@@ -113,7 +122,7 @@ public class ConstructorReferencesSearchHelper {
       public boolean process(PsiClass inheritor) {
         final PsiElement navigationElement = inheritor.getNavigationElement();
         if (navigationElement instanceof PsiClass) {
-          return processSuperOrThis((PsiClass)navigationElement, constructor, constructorCanBeCalledImplicitly[0], searchScope,
+          return processSuperOrThis((PsiClass)navigationElement, constructor, constructorCanBeCalledImplicitly[0], searchScope, project,
                                     isStrictSignatureSearch, PsiKeyword.SUPER, processor);
         }
         return true;
@@ -125,8 +134,9 @@ public class ConstructorReferencesSearchHelper {
 
   private static boolean processEnumReferences(@NotNull final Processor<PsiReference> processor,
                                                @NotNull final PsiMethod constructor,
+                                               @NotNull final Project project,
                                                @NotNull final PsiClass aClass) {
-    return DumbService.getInstance(constructor.getProject()).runReadActionInSmartMode(new Computable<Boolean>() {
+    return DumbService.getInstance(project).runReadActionInSmartMode(new Computable<Boolean>() {
       @Override
       public Boolean compute() {
         for (PsiField field : aClass.getFields()) {
@@ -146,13 +156,14 @@ public class ConstructorReferencesSearchHelper {
 
   private static boolean process18MethodPointers(@NotNull final Processor<PsiReference> processor,
                                                  @NotNull final PsiMethod constructor,
+                                                 @NotNull final Project project,
                                                  @NotNull PsiClass aClass, SearchScope searchScope) {
     return ReferencesSearch.search(aClass, searchScope).forEach(new Processor<PsiReference>() {
       @Override
       public boolean process(PsiReference reference) {
         final PsiElement element = reference.getElement();
         if (element != null) {
-          return DumbService.getInstance(element.getProject()).runReadActionInSmartMode(new Computable<Boolean>() {
+          return DumbService.getInstance(project).runReadActionInSmartMode(new Computable<Boolean>() {
             @Override
             public Boolean compute() {
               final PsiElement parent = element.getParent();
@@ -175,12 +186,13 @@ public class ConstructorReferencesSearchHelper {
                                      @NotNull PsiMethod constructor,
                                      final boolean constructorCanBeCalledImplicitly,
                                      @NotNull SearchScope searchScope,
+                                     @NotNull Project project,
                                      final boolean isStrictSignatureSearch,
                                      @NotNull String superOrThisKeyword,
                                      @NotNull Processor<PsiReference> processor) {
     PsiMethod[] constructors = inheritor.getConstructors();
     if (constructors.length == 0 && constructorCanBeCalledImplicitly) {
-      if (!processImplicitConstructorCall(inheritor, processor, constructor, inheritor)) return false;
+      if (!processImplicitConstructorCall(inheritor, processor, constructor, project, inheritor)) return false;
     }
     for (PsiMethod method : constructors) {
       PsiCodeBlock body = method.getBody();
@@ -212,7 +224,7 @@ public class ConstructorReferencesSearchHelper {
         }
       }
       if (constructorCanBeCalledImplicitly) {
-        if (!processImplicitConstructorCall(method, processor, constructor, inheritor)) return false;
+        if (!processImplicitConstructorCall(method, processor, constructor, project, inheritor)) return false;
       }
     }
 
@@ -222,9 +234,10 @@ public class ConstructorReferencesSearchHelper {
   private boolean processImplicitConstructorCall(@NotNull final PsiMember usage,
                                                  @NotNull final Processor<PsiReference> processor,
                                                  @NotNull final PsiMethod constructor,
+                                                 @NotNull final Project project,
                                                  @NotNull final PsiClass containingClass) {
     if (containingClass instanceof PsiAnonymousClass) return true;
-    boolean same = DumbService.getInstance(constructor.getProject()).runReadActionInSmartMode(new Computable<Boolean>() {
+    boolean same = DumbService.getInstance(project).runReadActionInSmartMode(new Computable<Boolean>() {
       @Override
       public Boolean compute() {
         return myManager.areElementsEquivalent(constructor.getContainingClass(), containingClass.getSuperClass());
diff --git a/java/java-indexing-impl/src/com/intellij/psi/impl/search/ConstructorReferencesSearcher.java b/java/java-indexing-impl/src/com/intellij/psi/impl/search/ConstructorReferencesSearcher.java
index 1c48c5c5c367..1293937540b2 100644
--- a/java/java-indexing-impl/src/com/intellij/psi/impl/search/ConstructorReferencesSearcher.java
+++ b/java/java-indexing-impl/src/com/intellij/psi/impl/search/ConstructorReferencesSearcher.java
@@ -39,6 +39,6 @@ public class ConstructorReferencesSearcher extends QueryExecutorBase<PsiReferenc
       }
     });
     new ConstructorReferencesSearchHelper(manager[0])
-      .processConstructorReferences(consumer, method, aClass, scope, p.isIgnoreAccessScope(), true, p.getOptimizer());
+      .processConstructorReferences(consumer, method, aClass, scope, p.getProject(), p.isIgnoreAccessScope(), true, p.getOptimizer());
   }
 }
diff --git a/java/java-indexing-impl/src/com/intellij/psi/impl/search/MethodUsagesSearcher.java b/java/java-indexing-impl/src/com/intellij/psi/impl/search/MethodUsagesSearcher.java
index 3c38ab375b6b..b9a31eba1fb0 100644
--- a/java/java-indexing-impl/src/com/intellij/psi/impl/search/MethodUsagesSearcher.java
+++ b/java/java-indexing-impl/src/com/intellij/psi/impl/search/MethodUsagesSearcher.java
@@ -43,7 +43,7 @@ public class MethodUsagesSearcher extends QueryExecutorBase<PsiReference, Method
     final boolean[] needStrictSignatureSearch = new boolean[1];
     final boolean strictSignatureSearch = p.isStrictSignatureSearch();
 
-    final PsiClass aClass = DumbService.getInstance(method.getProject()).runReadActionInSmartMode(new Computable<PsiClass>() {
+    final PsiClass aClass = DumbService.getInstance(p.getProject()).runReadActionInSmartMode(new Computable<PsiClass>() {
       public PsiClass compute() {
         PsiClass aClass = method.getContainingClass();
         if (aClass == null) return null;
@@ -65,7 +65,7 @@ public class MethodUsagesSearcher extends QueryExecutorBase<PsiReference, Method
 
     final SearchRequestCollector collector = p.getOptimizer();
 
-    final SearchScope searchScope = DumbService.getInstance(method.getProject()).runReadActionInSmartMode(new Computable<SearchScope>() {
+    final SearchScope searchScope = DumbService.getInstance(p.getProject()).runReadActionInSmartMode(new Computable<SearchScope>() {
       @Override
       public SearchScope compute() {
         return p.getEffectiveSearchScope();
@@ -74,7 +74,7 @@ public class MethodUsagesSearcher extends QueryExecutorBase<PsiReference, Method
 
     if (isConstructor[0]) {
       new ConstructorReferencesSearchHelper(psiManager[0]).
-        processConstructorReferences(consumer, method, aClass, searchScope, false, strictSignatureSearch, collector);
+        processConstructorReferences(consumer, method, aClass, searchScope, p.getProject(), false, strictSignatureSearch, collector);
     }
 
     if (isValueAnnotation[0]) {
@@ -91,7 +91,7 @@ public class MethodUsagesSearcher extends QueryExecutorBase<PsiReference, Method
       return;
     }
 
-    DumbService.getInstance(method.getProject()).runReadActionInSmartMode(new Runnable() {
+    DumbService.getInstance(p.getProject()).runReadActionInSmartMode(new Runnable() {
       public void run() {
         final PsiMethod[] methods = strictSignatureSearch ? new PsiMethod[]{method} : aClass.findMethodsByName(methodName[0], false);
         SearchScope accessScope = methods[0].getUseScope();
diff --git a/platform/indexing-api/src/com/intellij/psi/search/searches/ReferencesSearch.java b/platform/indexing-api/src/com/intellij/psi/search/searches/ReferencesSearch.java
index 07791dd1f51f..88ed856c92c9 100644
--- a/platform/indexing-api/src/com/intellij/psi/search/searches/ReferencesSearch.java
+++ b/platform/indexing-api/src/com/intellij/psi/search/searches/ReferencesSearch.java
@@ -16,6 +16,7 @@
 package com.intellij.psi.search.searches;
 
 import com.intellij.openapi.extensions.ExtensionPointName;
+import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiReference;
 import com.intellij.psi.search.*;
@@ -43,6 +44,7 @@ public class ReferencesSearch extends ExtensibleQueryFactory<PsiReference, Refer
     private final SearchScope myScope;
     private final boolean myIgnoreAccessScope;
     private final SearchRequestCollector myOptimizer;
+    private final Project myProject;
     private final boolean isSharedOptimizer;
 
     public SearchParameters(@NotNull PsiElement elementToSearch, @NotNull SearchScope scope, boolean ignoreAccessScope, @Nullable SearchRequestCollector optimizer) {
@@ -51,12 +53,18 @@ public class ReferencesSearch extends ExtensibleQueryFactory<PsiReference, Refer
       myIgnoreAccessScope = ignoreAccessScope;
       isSharedOptimizer = optimizer != null;
       myOptimizer = optimizer == null ? new SearchRequestCollector(new SearchSession()) : optimizer;
+      myProject = PsiUtilCore.getProjectInReadAction(elementToSearch);
     }
 
     public SearchParameters(@NotNull PsiElement elementToSearch, @NotNull SearchScope scope, final boolean ignoreAccessScope) {
       this(elementToSearch, scope, ignoreAccessScope, null);
     }
 
+    @NotNull
+    public Project getProject() {
+      return myProject;
+    }
+
     @NotNull
     public PsiElement getElementToSearch() {
       return myElementToSearch;