usages view: regression: exclude/include action must be available only on UsagesNode-s and don't produce class cast exceptions IDEA-157266

platform/lang-impl/src/com/intellij/codeInspection/ui/InspectionResultsView.java

@@ -163,6 +163,11 @@ public class InspectionResultsView extends JPanel implements Disposable, Occuren
     });
     add(mySplitter, BorderLayout.CENTER);
     myExclusionHandler = new ExclusionHandler<InspectionTreeNode>() {
+      @Override
+      public boolean isNodeExclusionAvailable(@NotNull InspectionTreeNode node) {
+        return true;
+      }
+
       @Override
       public boolean isNodeExcluded(@NotNull InspectionTreeNode node) {
         return node.isExcluded(myExcludedInspectionTreeNodesManager);

platform/platform-api/src/com/intellij/ide/actions/exclusion/ExclusionHandler.java

@@ -26,6 +26,8 @@ import javax.swing.tree.MutableTreeNode;
 public interface ExclusionHandler<T extends MutableTreeNode> {
   DataKey<ExclusionHandler> EXCLUSION_HANDLER = DataKey.create("tree.exclusion.handler");
 
+  boolean isNodeExclusionAvailable(@NotNull T node);
+
   boolean isNodeExcluded(@NotNull T node);
 
   void excludeNode(@NotNull T node);

platform/platform-api/src/com/intellij/ide/actions/exclusion/TreeNodeExclusionAction.java

@@ -63,6 +63,7 @@ abstract class TreeNodeExclusionAction<T extends MutableTreeNode> extends AnActi
     for (TreePath path : selection) {
       final T node = (T)path.getLastPathComponent();
       TreeUtil.traverse(node, n -> {
+        if (!exclusionProcessor.isNodeExclusionAvailable((T)n)) return true;
         final Boolean isNodeExcluded = exclusionProcessor.isNodeExcluded((T)n);
         if (myIsExclude != isNodeExcluded) {
           isEnabled[0] = true;

platform/usageView/src/com/intellij/usages/impl/UsageViewImpl.java

@@ -106,7 +106,7 @@ public class UsageViewImpl implements UsageView, UsageModelTracker.UsageModelTra
   private final ExporterToTextFile myTextFileExporter = new ExporterToTextFile(this);
   private final Alarm myUpdateAlarm = new Alarm(Alarm.ThreadToUse.SWING_THREAD);
 
-  private final ExclusionHandler<Node> myExclusionHandler;
+  private final ExclusionHandler<DefaultMutableTreeNode> myExclusionHandler;
   private final UsageModelTracker myModelTracker;
   private final Map<Usage, UsageNode> myUsageNodes = new ConcurrentHashMap<Usage, UsageNode>();
   public static final UsageNode NULL_NODE = new UsageNode(NullUsage.INSTANCE, new UsageViewTreeModelBuilder(new UsageViewPresentation(), UsageTarget.EMPTY_ARRAY));
@@ -253,21 +253,26 @@ public class UsageViewImpl implements UsageView, UsageModelTracker.UsageModelTra
       runnable.run();
       return true;
     }, o -> isDisposed || project.isDisposed(), 200);
-    myExclusionHandler = new ExclusionHandler<Node>() {
+    myExclusionHandler = new ExclusionHandler<DefaultMutableTreeNode>() {
       @Override
-      public boolean isNodeExcluded(@NotNull Node node) {
-        return node.isDataExcluded();
+      public boolean isNodeExclusionAvailable(@NotNull DefaultMutableTreeNode node) {
+        return node instanceof UsageNode;
       }
 
       @Override
-      public void excludeNode(@NotNull Node node) {
+      public boolean isNodeExcluded(@NotNull DefaultMutableTreeNode node) {
+        return ((UsageNode)node).isDataExcluded();
+      }
+
+      @Override
+      public void excludeNode(@NotNull DefaultMutableTreeNode node) {
         final HashSet<Usage> usages = new HashSet<>();
         collectUsages(node, usages);
         excludeUsages(usages.toArray(new Usage[usages.size()]));
       }
 
       @Override
-      public void includeNode(@NotNull Node node) {
+      public void includeNode(@NotNull DefaultMutableTreeNode node) {
         final HashSet<Usage> usages = new HashSet<>();
         collectUsages(node, usages);
         includeUsages(usages.toArray(new Usage[usages.size()]));