Cleanup (warnings; formatting) master
authorRoman Shevchenko <roman.shevchenko@jetbrains.com>
Tue, 28 Sep 2021 19:10:50 +0000 (21:10 +0200)
committerintellij-monorepo-bot <intellij-monorepo-bot-no-reply@jetbrains.com>
Tue, 28 Sep 2021 19:30:52 +0000 (19:30 +0000)
GitOrigin-RevId: b1bb4365a6ee8d98e3f57998aa3351d3f7b53a12

platform/util-class-loader/src/com/intellij/util/lang/UrlClassLoader.java

index 2954ec76b6ff5ffb57cdfca236317c93e95128f2..08fd1579a9b2ad3a6226b27acb8e3aeea51b0049 100644 (file)
@@ -56,10 +56,9 @@ public class UrlClassLoader extends ClassLoader implements ClassPath.ClassDataCo
   }
 
   /**
   }
 
   /**
-   * There are two definitions of ClassPath class.
-   * First one from app class loader that used by bootstrap.
-   * Another one from core class loader that created as result of creating of plugin class loader.
-   * Core class loader doesn't use bootstrap class loader as parent, instead, only platform classloader is used (only JDK classes).
+   * There are two definitions of the `ClassPath` class: one from the app class loader that is used by bootstrap,
+   * and another one from the core class loader produced as a result of creating of plugin class loader.
+   * The core class loader doesn't use bootstrap class loader as a parent - instead, only platform classloader is used (only JRE classes).
    */
   @ApiStatus.Internal
   public final @NotNull ClassPath getClassPath() {
    */
   @ApiStatus.Internal
   public final @NotNull ClassPath getClassPath() {
@@ -104,8 +103,7 @@ public class UrlClassLoader extends ClassLoader implements ClassPath.ClassDataCo
       f.setAccessible(true);
       f.set(classLoader, f.get(parent));
     }
       f.setAccessible(true);
       f.set(classLoader, f.get(parent));
     }
-    catch (Exception ignored) {
-    }
+    catch (Exception ignored) { }
   }
 
   protected static @NotNull UrlClassLoader.Builder createDefaultBuilderForJdk(@NotNull ClassLoader parent) {
   }
 
   protected static @NotNull UrlClassLoader.Builder createDefaultBuilderForJdk(@NotNull ClassLoader parent) {
@@ -200,8 +198,7 @@ public class UrlClassLoader extends ClassLoader implements ClassPath.ClassDataCo
       try {
         result.add(file.toUri().toURL());
       }
       try {
         result.add(file.toUri().toURL());
       }
-      catch (MalformedURLException ignored) {
-      }
+      catch (MalformedURLException ignored) { }
     }
     return result;
   }
     }
     return result;
   }
@@ -234,14 +231,14 @@ public class UrlClassLoader extends ClassLoader implements ClassPath.ClassDataCo
     return clazz;
   }
 
     return clazz;
   }
 
-  private void definePackageIfNeeded(@NotNull String name, Loader loader) throws IOException {
+  private void definePackageIfNeeded(String name, Loader loader) throws IOException {
     int lastDotIndex = name.lastIndexOf('.');
     if (lastDotIndex == -1) {
       return;
     }
 
     String packageName = name.substring(0, lastDotIndex);
     int lastDotIndex = name.lastIndexOf('.');
     if (lastDotIndex == -1) {
       return;
     }
 
     String packageName = name.substring(0, lastDotIndex);
-    // check if package already loaded
+    // check if the package is already loaded
     if (isPackageDefined(packageName)) {
       return;
     }
     if (isPackageDefined(packageName)) {
       return;
     }
@@ -263,12 +260,12 @@ public class UrlClassLoader extends ClassLoader implements ClassPath.ClassDataCo
       }
     }
     catch (IllegalArgumentException ignore) {
       }
     }
     catch (IllegalArgumentException ignore) {
-      // do nothing, package already defined by some another thread
+      // do nothing, the package is already defined by another thread
     }
   }
 
     }
   }
 
+  @SuppressWarnings("deprecation")
   protected boolean isPackageDefined(String packageName) {
   protected boolean isPackageDefined(String packageName) {
-    //noinspection deprecation
     return getPackage(packageName) != null;
   }
 
     return getPackage(packageName) != null;
   }
 
@@ -282,15 +279,13 @@ public class UrlClassLoader extends ClassLoader implements ClassPath.ClassDataCo
   }
 
   @Override
   }
 
   @Override
-  public Class<?> consumeClassData(@NotNull String name, byte[] data, Loader loader, @Nullable ProtectionDomain protectionDomain)
-    throws IOException {
+  public Class<?> consumeClassData(@NotNull String name, byte[] data, Loader loader, @Nullable ProtectionDomain protectionDomain) throws IOException {
     definePackageIfNeeded(name, loader);
     return super.defineClass(name, data, 0, data.length, protectionDomain == null ? getProtectionDomain() : protectionDomain);
   }
 
   @Override
     definePackageIfNeeded(name, loader);
     return super.defineClass(name, data, 0, data.length, protectionDomain == null ? getProtectionDomain() : protectionDomain);
   }
 
   @Override
-  public Class<?> consumeClassData(@NotNull String name, ByteBuffer data, Loader loader, @Nullable ProtectionDomain protectionDomain)
-    throws IOException {
+  public Class<?> consumeClassData(@NotNull String name, ByteBuffer data, Loader loader, @Nullable ProtectionDomain protectionDomain) throws IOException {
     definePackageIfNeeded(name, loader);
     return super.defineClass(name, data, protectionDomain == null ? getProtectionDomain() : protectionDomain);
   }
     definePackageIfNeeded(name, loader);
     return super.defineClass(name, data, protectionDomain == null ? getProtectionDomain() : protectionDomain);
   }
@@ -336,7 +331,7 @@ public class UrlClassLoader extends ClassLoader implements ClassPath.ClassDataCo
     return null;
   }
 
     return null;
   }
 
-  private @Nullable Resource doFindResource(@NotNull String name) {
+  private @Nullable Resource doFindResource(String name) {
     String canonicalPath = toCanonicalPath(name);
     Resource resource = classPath.findResource(canonicalPath);
     if (resource == null && canonicalPath.startsWith("/") && classPath.findResource(canonicalPath.substring(1)) != null) {
     String canonicalPath = toCanonicalPath(name);
     Resource resource = classPath.findResource(canonicalPath);
     if (resource == null && canonicalPath.startsWith("/") && classPath.findResource(canonicalPath.substring(1)) != null) {
@@ -378,8 +373,7 @@ public class UrlClassLoader extends ClassLoader implements ClassPath.ClassDataCo
           try {
             c = parent.loadClass(name);
           }
           try {
             c = parent.loadClass(name);
           }
-          catch (ClassNotFoundException ignore) {
-          }
+          catch (ClassNotFoundException ignore) { }
         }
 
         if (c != null) {
         }
 
         if (c != null) {
@@ -392,9 +386,9 @@ public class UrlClassLoader extends ClassLoader implements ClassPath.ClassDataCo
 
   /**
    * An interface for a pool to store internal caches that can be shared between different class loaders,
 
   /**
    * An interface for a pool to store internal caches that can be shared between different class loaders,
-   * if they contain the same URLs in their class paths.<p/>
-   *
-   * The implementation is subject to change so one shouldn't rely on it.
+   * if they contain the same URLs in their class paths.
+   * <p>
+   * The implementation is subject to change; one shouldn't rely on it.
    *
    * @see #createCachePool()
    * @see Builder#useCache
    *
    * @see #createCachePool()
    * @see Builder#useCache
@@ -479,7 +473,7 @@ public class UrlClassLoader extends ClassLoader implements ClassPath.ClassDataCo
   }
 
   @SuppressWarnings("DuplicatedCode")
   }
 
   @SuppressWarnings("DuplicatedCode")
-  private static void processDots(@NotNull StringBuilder result, int dots, int start) {
+  private static void processDots(StringBuilder result, int dots, int start) {
     if (dots == 2) {
       int pos = -1;
       if (!StringUtilRt.endsWith(result, "/../") && !"../".contentEquals(result)) {
     if (dots == 2) {
       int pos = -1;
       if (!StringUtilRt.endsWith(result, "/../") && !"../".contentEquals(result)) {
@@ -488,10 +482,10 @@ public class UrlClassLoader extends ClassLoader implements ClassPath.ClassDataCo
           ++pos;  // separator found, trim to next char
         }
         else if (start > 0) {
           ++pos;  // separator found, trim to next char
         }
         else if (start > 0) {
-          pos = start;  // path is absolute, trim to root ('/..' -> '/')
+          pos = start;  // the path is absolute, trim to root ('/..' -> '/')
         }
         else if (result.length() > 0) {
         }
         else if (result.length() > 0) {
-          pos = 0;  // path is relative, trim to default ('a/..' -> '')
+          pos = 0;  // the path is relative, trim to default ('a/..' -> '')
         }
       }
       if (pos >= 0) {
         }
       }
       if (pos >= 0) {
@@ -510,7 +504,7 @@ public class UrlClassLoader extends ClassLoader implements ClassPath.ClassDataCo
   }
 
   @SuppressWarnings("DuplicatedCode")
   }
 
   @SuppressWarnings("DuplicatedCode")
-  private static int processRoot(@NotNull String path, @NotNull StringBuilder result) {
+  private static int processRoot(String path, StringBuilder result) {
     if (!path.isEmpty() && path.charAt(0) == '/') {
       result.append('/');
       return 1;
     if (!path.isEmpty() && path.charAt(0) == '/') {
       result.append('/');
       return 1;
@@ -603,9 +597,10 @@ public class UrlClassLoader extends ClassLoader implements ClassPath.ClassDataCo
     }
 
     /**
     }
 
     /**
-     * ZipFile handles opened in JarLoader will be kept in SoftReference. Depending on OS, the option significantly speeds up classloading
-     * from libraries. Caveat: for Windows opened handle will lock the file preventing its modification.
-     * Thus, the option is recommended when jars are not modified or process that uses this option is transient.
+     * `ZipFile` handles opened in `JarLoader` will be kept in as soft references.
+     * Depending on OS, the option significantly speeds up classloading from libraries.
+     * Caveat: on Windows, unclosed handle locks a file, preventing its modification.
+     * Thus, the option is recommended when .jar files are not modified or a process that uses this option is transient.
      */
     public @NotNull UrlClassLoader.Builder allowLock(boolean lockJars) {
       this.lockJars = lockJars;
      */
     public @NotNull UrlClassLoader.Builder allowLock(boolean lockJars) {
       this.lockJars = lockJars;
@@ -613,7 +608,7 @@ public class UrlClassLoader extends ClassLoader implements ClassPath.ClassDataCo
     }
 
     /**
     }
 
     /**
-     * Build backward index of packages / class or resource names that allows avoiding IO during classloading.
+     * Build a backward index of packages to class/resource names; allows to reduce I/O during classloading.
      */
     public @NotNull UrlClassLoader.Builder useCache() {
       useCache = true;
      */
     public @NotNull UrlClassLoader.Builder useCache() {
       useCache = true;
@@ -626,13 +621,13 @@ public class UrlClassLoader extends ClassLoader implements ClassPath.ClassDataCo
     }
 
     /**
     }
 
     /**
-     * FileLoader will save list of files / packages under its root and use this information instead of walking filesystem for
-     * speedier classloading. Should be used only when the caches could be properly invalidated, e.g. when new file appears under
-     * FileLoader's root. Currently, the flag is used for faster unit test / developed Idea running, because Idea's make (as of 14.1) ensures deletion of
+     * `FileLoader` will save a list of files/packages under its root and use this information instead of walking files.
+     * Should be used only when the caches can be properly invalidated (when e.g. a new file appears under `FileLoader`'s root).
+     * Currently, the flag is used for faster unit tests / debug IDE instance, because IDEA's build process (as of 14.1) ensures deletion of
      * such information upon appearing new file for output root.
      * such information upon appearing new file for output root.
-     * N.b. Idea make does not ensure deletion of cached information upon deletion of some file under local root but false positives are not a
-     * logical error since code is prepared for that and disk access is performed upon class / resource loading.
-     * See also Builder#usePersistentClasspathIndexForLocalClassDirectories.
+     * <p>
+     * N.b. IDEA's build process does not ensure deletion of cached information upon deletion of some file under a local root,
+     * but false positives are not a logical error, since code is prepared for that and disk access is performed upon class/resource loading.
      */
     public @NotNull UrlClassLoader.Builder usePersistentClasspathIndexForLocalClassDirectories() {
       this.isClassPathIndexEnabled = isClassPathIndexEnabledGlobalValue;
      */
     public @NotNull UrlClassLoader.Builder usePersistentClasspathIndexForLocalClassDirectories() {
       this.isClassPathIndexEnabled = isClassPathIndexEnabledGlobalValue;