cleanup
authorAlexey Kudravtsev <cdr@intellij.com>
Wed, 12 Aug 2020 21:07:58 +0000 (00:07 +0300)
committerintellij-monorepo-bot <intellij-monorepo-bot-no-reply@jetbrains.com>
Thu, 13 Aug 2020 10:51:46 +0000 (10:51 +0000)
GitOrigin-RevId: 4ce3174189219cebdea5ac559e7baf5005089364

platform/util/src/com/intellij/openapi/util/Disposer.java
platform/util/src/com/intellij/openapi/util/ObjectNode.java
platform/util/src/com/intellij/openapi/util/ObjectTree.java

index 3648a95307facceccd496c6584b45e63b8f5d906..ebc268738d94adf303de596eb36883a5acb3117e 100644 (file)
@@ -2,6 +2,7 @@
 package com.intellij.openapi.util;
 
 import com.intellij.openapi.Disposable;
+import com.intellij.util.IncorrectOperationException;
 import com.intellij.util.ObjectUtils;
 import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.*;
@@ -67,7 +68,7 @@ public final class Disposer {
    * @throws com.intellij.util.IncorrectOperationException If {@code child} has been registered with {@code parent} before;
    *                                                       if {@code parent} is being disposed or already disposed ({@link #isDisposed(Disposable)}.
    */
-  public static void register(@NotNull Disposable parent, @NotNull Disposable child) {
+  public static void register(@NotNull Disposable parent, @NotNull Disposable child) throws IncorrectOperationException {
     RuntimeException e = ourTree.register(parent, child);
     if (e != null) throw e;
   }
index 3bf13de529f67353987a08c32a2a3a1eef8c27b2..f52f2429cbc6cadfa88d89552ccce511a79bca99 100644 (file)
@@ -18,7 +18,7 @@ final class ObjectNode {
   private final Disposable myObject;
 
   private List<ObjectNode> myChildren; // guarded by myTree.treeLock
-  private Throwable myTrace;
+  private Throwable myTrace; // guarded by myTree.treeLock
 
   ObjectNode(@NotNull ObjectTree tree,
              @Nullable ObjectNode parentNode,
@@ -57,18 +57,11 @@ final class ObjectNode {
   }
 
   ObjectNode getParent() {
-    synchronized (myTree.treeLock) {
-      return myParent;
-    }
+    return myParent;
   }
 
   void getAndRemoveRecursively(@NotNull List<? super Disposable> result) {
-    if (myChildren != null) {
-      for (int i = myChildren.size() - 1; i >= 0; i--) {
-        ObjectNode childNode = myChildren.get(i);
-        childNode.getAndRemoveRecursively(result);
-      }
-    }
+    getAndRemoveChildrenRecursively(result);
     myTree.removeObjectFromTree(this);
     // already disposed. may happen when someone does `register(obj, ()->Disposer.dispose(t));` abomination
     if (myTree.rememberDisposedTrace(myObject) == null) {
index 348190fd6447e98de242d156f1c2e0976f5989cd..236f60dc600380851dca7c9681c421dec1ccbe23 100644 (file)
@@ -27,7 +27,7 @@ final class ObjectTree {
   // Disposable -> trace or boolean marker (if trace unavailable)
   private final Map<Disposable, Object> myDisposedObjects = ContainerUtil.createWeakMap(100, 0.5f, ContainerUtil.identityStrategy()); // guarded by treeLock
 
-  final Object treeLock = new Object();
+  private final Object treeLock = new Object();
 
   private ObjectNode getNode(@NotNull Disposable object) {
     return myObject2NodeMap.get(object);
@@ -102,7 +102,7 @@ final class ObjectTree {
     return newNode;
   }
 
-  private void runWithTrace(@NotNull Supplier<? extends List<Disposable>> removeFromTreeAction) {
+  private void runWithTrace(@NotNull Supplier<? extends @NotNull List<Disposable>> removeFromTreeAction) {
     boolean needTrace = Disposer.isDebugMode() && ourTopmostDisposeTrace.get() == null;
     if (needTrace) {
       ourTopmostDisposeTrace.set(ThrowableInterner.intern(new Throwable()));