diff --git a/java/java-indexing-impl/src/com/intellij/psi/impl/search/JavaDirectInheritorsSearcher.java b/java/java-indexing-impl/src/com/intellij/psi/impl/search/JavaDirectInheritorsSearcher.java
index a0ea9b3fd68f..077985db8c34 100644
--- a/java/java-indexing-impl/src/com/intellij/psi/impl/search/JavaDirectInheritorsSearcher.java
+++ b/java/java-indexing-impl/src/com/intellij/psi/impl/search/JavaDirectInheritorsSearcher.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2015 JetBrains s.r.o.
+ * Copyright 2000-2016 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.
@@ -51,87 +51,46 @@ public class JavaDirectInheritorsSearcher implements QueryExecutor<PsiClass, Dir
   public boolean execute(@NotNull final DirectClassInheritorsSearch.SearchParameters p, @NotNull final Processor<PsiClass> consumer) {
     final PsiClass aClass = p.getClassToProcess();
 
-    final SearchScope useScope = ApplicationManager.getApplication().runReadAction(new Computable<SearchScope>() {
-      @Override
-      public SearchScope compute() {
-        return aClass.getUseScope();
-      }
-    });
+    final SearchScope useScope = ApplicationManager.getApplication().runReadAction((Computable<SearchScope>)aClass::getUseScope);
 
-    final String qualifiedName = ApplicationManager.getApplication().runReadAction(new Computable<String>() {
-      @Override
-      public String compute() {
-        return aClass.getQualifiedName();
-      }
-    });
+    final String qualifiedName = ApplicationManager.getApplication().runReadAction((Computable<String>)aClass::getQualifiedName);
 
     final Project project = PsiUtilCore.getProjectInReadAction(aClass);
     if (CommonClassNames.JAVA_LANG_OBJECT.equals(qualifiedName)) {
-      //[pasynkov]: WTF?
-      //final SearchScope scope = useScope.intersectWith(GlobalSearchScope.notScope(GlobalSearchScope.getScopeRestrictedByFileTypes(
-      //    GlobalSearchScope.allScope(psiManager.getProject()), StdFileTypes.JSP, StdFileTypes.JSPX)));
-
-      return AllClassesSearch.search(useScope, project).forEach(new Processor<PsiClass>() {
-        @Override
-        public boolean process(final PsiClass psiClass) {
-          ProgressManager.checkCanceled();
-          if (psiClass.isInterface()) {
-            return consumer.process(psiClass);
-          }
-          final PsiClass superClass = psiClass.getSuperClass();
-          if (superClass != null && CommonClassNames.JAVA_LANG_OBJECT.equals(ApplicationManager.getApplication().runReadAction(new Computable<String>() {
-            public String compute() {
-              return superClass.getQualifiedName();
-            }
-          }))) {
-            return consumer.process(psiClass);
-          }
-          return true;
+      return AllClassesSearch.search(useScope, project).forEach(psiClass -> {
+        ProgressManager.checkCanceled();
+        if (psiClass.isInterface()) {
+          return consumer.process(psiClass);
         }
+        final PsiClass superClass = psiClass.getSuperClass();
+        if (superClass != null &&
+            CommonClassNames.JAVA_LANG_OBJECT.equals(ApplicationManager.getApplication().runReadAction((Computable<String>)superClass::getQualifiedName))) {
+          return consumer.process(psiClass);
+        }
+        return true;
       });
     }
 
     final GlobalSearchScope scope = useScope instanceof GlobalSearchScope ? (GlobalSearchScope)useScope : new EverythingGlobalScope(project);
-    final String searchKey = ApplicationManager.getApplication().runReadAction(new Computable<String>() {
-      @Override
-      public String compute() {
-        return aClass.getName();
-      }
-    });
+    final String searchKey = ApplicationManager.getApplication().runReadAction((Computable<String>)aClass::getName);
     if (StringUtil.isEmpty(searchKey)) {
       return true;
     }
 
-    Collection<PsiReferenceList> candidates = MethodUsagesSearcher.resolveInReadAction(project,
-                                                                                       new Computable<Collection<PsiReferenceList>>() {
-                                                                                         @Override
-                                                                                         public Collection<PsiReferenceList> compute() {
-                                                                                           return JavaSuperClassNameOccurenceIndex
-                                                                                             .getInstance().get(searchKey, project, scope);
-                                                                                         }
-                                                                                       });
+    Collection<PsiReferenceList> candidates =
+      MethodUsagesSearcher.resolveInReadAction(project, () -> JavaSuperClassNameOccurenceIndex.getInstance().get(searchKey, project, scope));
 
-    Map<String, List<PsiClass>> classes = new HashMap<String, List<PsiClass>>();
+    Map<String, List<PsiClass>> classes = new HashMap<>();
 
     for (final PsiReferenceList referenceList : candidates) {
       ProgressManager.checkCanceled();
-      final PsiClass candidate = (PsiClass)ApplicationManager.getApplication().runReadAction(new Computable<PsiElement>() {
-        @Override
-        public PsiElement compute() {
-          return referenceList.getParent();
-        }
-      });
+      final PsiClass candidate = (PsiClass)ApplicationManager.getApplication().runReadAction((Computable<PsiElement>)referenceList::getParent);
       if (!checkInheritance(p, aClass, candidate, project)) continue;
 
-      String fqn = ApplicationManager.getApplication().runReadAction(new Computable<String>() {
-        @Override
-        public String compute() {
-          return candidate.getQualifiedName();
-        }
-      });
+      String fqn = ApplicationManager.getApplication().runReadAction((Computable<String>)candidate::getQualifiedName);
       List<PsiClass> list = classes.get(fqn);
       if (list == null) {
-        list = new ArrayList<PsiClass>();
+        list = new ArrayList<>();
         classes.put(fqn, list);
       }
       list.add(candidate);
@@ -146,15 +105,8 @@ public class JavaDirectInheritorsSearcher implements QueryExecutor<PsiClass, Dir
     }
 
     if (p.includeAnonymous()) {
-      Collection<PsiAnonymousClass> anonymousCandidates = MethodUsagesSearcher.resolveInReadAction(project,
-                                                                                                   new Computable<Collection<PsiAnonymousClass>>() {
-                                                                                                     @Override
-                                                                                                     public Collection<PsiAnonymousClass> compute() {
-                                                                                                       return JavaAnonymousClassBaseRefOccurenceIndex
-                                                                                                         .getInstance()
-                                                                                                         .get(searchKey, project, scope);
-                                                                                                     }
-                                                                                                   });
+      Collection<PsiAnonymousClass> anonymousCandidates =
+        MethodUsagesSearcher.resolveInReadAction(project, () -> JavaAnonymousClassBaseRefOccurenceIndex.getInstance().get(searchKey, project, scope));
 
       for (PsiAnonymousClass candidate : anonymousCandidates) {
         ProgressManager.checkCanceled();
@@ -163,30 +115,15 @@ public class JavaDirectInheritorsSearcher implements QueryExecutor<PsiClass, Dir
         if (!consumer.process(candidate)) return false;
       }
 
-      boolean isEnum = ApplicationManager.getApplication().runReadAction(new Computable<Boolean>() {
-        @Override
-        public Boolean compute() {
-          return aClass.isEnum();
-        }
-      });
+      boolean isEnum = ApplicationManager.getApplication().runReadAction((Computable<Boolean>)aClass::isEnum);
       if (isEnum) {
         // abstract enum can be subclassed in the body
-        PsiField[] fields = ApplicationManager.getApplication().runReadAction(new Computable<PsiField[]>() {
-          @Override
-          public PsiField[] compute() {
-            return aClass.getFields();
-          }
-        });
+        PsiField[] fields = ApplicationManager.getApplication().runReadAction((Computable<PsiField[]>)aClass::getFields);
         for (final PsiField field : fields) {
           ProgressManager.checkCanceled();
           if (field instanceof PsiEnumConstant) {
             PsiEnumConstantInitializer initializingClass =
-              ApplicationManager.getApplication().runReadAction(new Computable<PsiEnumConstantInitializer>() {
-                @Override
-                public PsiEnumConstantInitializer compute() {
-                  return ((PsiEnumConstant)field).getInitializingClass();
-                }
-              });
+              ApplicationManager.getApplication().runReadAction((Computable<PsiEnumConstantInitializer>)((PsiEnumConstant)field)::getInitializingClass);
             if (initializingClass != null) {
               if (!consumer.process(initializingClass)) return false;
             }
@@ -199,12 +136,7 @@ public class JavaDirectInheritorsSearcher implements QueryExecutor<PsiClass, Dir
   }
 
   private static boolean checkInheritance(final DirectClassInheritorsSearch.SearchParameters p, final PsiClass aClass, final PsiClass candidate, Project project) {
-    return MethodUsagesSearcher.resolveInReadAction(project, new Computable<Boolean>() {
-      @Override
-      public Boolean compute() {
-        return !p.isCheckInheritance() || candidate.isInheritor(aClass, false);
-      }
-    });
+    return MethodUsagesSearcher.resolveInReadAction(project, () -> !p.isCheckInheritance() || candidate.isInheritor(aClass, false));
   }
 
   private static boolean processSameNamedClasses(Processor<PsiClass> consumer, List<PsiClass> sameNamedClasses, final VirtualFile jarFile) {
@@ -226,11 +158,6 @@ public class JavaDirectInheritorsSearcher implements QueryExecutor<PsiClass, Dir
   }
 
   private static VirtualFile getJarFile(final PsiClass aClass) {
-    return ApplicationManager.getApplication().runReadAction(new Computable<VirtualFile>() {
-      @Override
-      public VirtualFile compute() {
-        return PsiUtil.getJarFile(aClass);
-      }
-    });
+    return ApplicationManager.getApplication().runReadAction((Computable<VirtualFile>)() -> PsiUtil.getJarFile(aClass));
   }
 }