diff --git a/platform/core-impl/src/com/intellij/ide/plugins/ClassLoaderConfigurator.java b/platform/core-impl/src/com/intellij/ide/plugins/ClassLoaderConfigurator.java
index 004bb00c70d3..352a7075b3e4 100644
--- a/platform/core-impl/src/com/intellij/ide/plugins/ClassLoaderConfigurator.java
+++ b/platform/core-impl/src/com/intellij/ide/plugins/ClassLoaderConfigurator.java
@@ -119,7 +119,7 @@ final class ClassLoaderConfigurator {
           getLogger().error(PluginLoadingError.formatErrorMessage(mainDependent,
                                                                   "requires missing class loader for '" + dependencyDescriptor.getName() + "'"));
         }
-        else if (loader != coreLoader || !usePluginClassLoader) {
+        else if (loader != coreLoader) {
           loaders.add(loader);
         }
       }
@@ -195,15 +195,15 @@ final class ClassLoaderConfigurator {
     }
   }
 
-  private static void addLoaderOrLogError(@NotNull IdeaPluginDescriptorImpl dependent,
-                                          @NotNull IdeaPluginDescriptorImpl dependency,
-                                          @NotNull Collection<ClassLoader> loaders) {
+  private void addLoaderOrLogError(@NotNull IdeaPluginDescriptorImpl dependent,
+                                   @NotNull IdeaPluginDescriptorImpl dependency,
+                                   @NotNull Collection<ClassLoader> loaders) {
     ClassLoader loader = dependency.getClassLoader();
     if (loader == null) {
       getLogger().error(PluginLoadingError.formatErrorMessage(dependent,
                                                               "requires missing class loader for '" + dependency.getName() + "'"));
     }
-    else {
+    else if (loader != coreLoader) {
       loaders.add(loader);
     }
   }
diff --git a/platform/core-impl/src/com/intellij/ide/plugins/cl/PluginClassLoader.java b/platform/core-impl/src/com/intellij/ide/plugins/cl/PluginClassLoader.java
index 0c59084b116e..c304b62bade5 100644
--- a/platform/core-impl/src/com/intellij/ide/plugins/cl/PluginClassLoader.java
+++ b/platform/core-impl/src/com/intellij/ide/plugins/cl/PluginClassLoader.java
@@ -5,6 +5,7 @@ import com.intellij.diagnostic.PluginException;
 import com.intellij.diagnostic.StartUpMeasurer;
 import com.intellij.openapi.application.Application;
 import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.extensions.PluginDescriptor;
 import com.intellij.openapi.extensions.PluginId;
 import com.intellij.util.ArrayUtil;
@@ -36,20 +37,19 @@ public final class PluginClassLoader extends UrlClassLoader implements PluginAwa
 
   private static final AtomicInteger instanceIdProducer = new AtomicInteger();
 
-  private ClassLoader[] myParents;
-  private final PluginDescriptor myPluginDescriptor;
-  private final List<String> myLibDirectories;
+  private ClassLoader[] parents;
+  private final PluginDescriptor pluginDescriptor;
+  private final List<String> libDirectories;
 
   private final AtomicLong edtTime = new AtomicLong();
   private final AtomicLong backgroundTime = new AtomicLong();
 
   private final AtomicInteger loadedClassCounter = new AtomicInteger();
-  private final ClassLoader myCoreLoader;
+  private final ClassLoader coreLoader;
 
   // to simplify analyzing of heap dump (dynamic plugin reloading)
   private final PluginId pluginId;
 
-
   private final int instanceId;
 
   public PluginClassLoader(@NotNull List<URL> urls,
@@ -68,21 +68,24 @@ public final class PluginClassLoader extends UrlClassLoader implements PluginAwa
 
     instanceId = instanceIdProducer.incrementAndGet();
 
-    myParents = parents;
-    myPluginDescriptor = pluginDescriptor;
+    this.parents = parents;
+    this.pluginDescriptor = pluginDescriptor;
     pluginId = pluginDescriptor.getPluginId();
-    myCoreLoader = coreLoader;
+    this.coreLoader = coreLoader;
     if (coreLoader != null && PluginClassLoader.class.desiredAssertionStatus()) {
-      for (ClassLoader parent : myParents) {
-        assert parent != coreLoader;
+      for (ClassLoader parent : this.parents) {
+        if (parent == coreLoader) {
+          Logger.getInstance(PluginClassLoader.class).error("Core loader must be not specified in parents " +
+                                                            "(parents=" + Arrays.toString(parents) + ", coreLoader=" + coreLoader + ")");
+        }
       }
     }
 
-    myLibDirectories = new SmartList<>();
+    libDirectories = new SmartList<>();
     if (pluginRoot != null) {
       Path libDir = pluginRoot.resolve("lib");
       if (Files.exists(libDir)) {
-        myLibDirectories.add(libDir.toAbsolutePath().toString());
+        libDirectories.add(libDir.toAbsolutePath().toString());
       }
     }
   }
@@ -149,8 +152,10 @@ public final class PluginClassLoader extends UrlClassLoader implements PluginAwa
                                                                              Set<ClassLoader> visited,
                                                                              ParameterType parameter,
                                                                              boolean withRoot) {
-    for (ClassLoader parent : myParents) {
-      assert parent != myCoreLoader;
+    for (ClassLoader parent : parents) {
+      if (parent == coreLoader) {
+        continue;
+      }
       if (visited == null) {
         visited = new HashSet<>();
         visited.add(this);
@@ -175,8 +180,8 @@ public final class PluginClassLoader extends UrlClassLoader implements PluginAwa
       }
     }
 
-    if (withRoot && myCoreLoader != null && (visited == null || visited.add(myCoreLoader))) {
-      return actionWithClassloader.execute(name, myCoreLoader, parameter);
+    if (withRoot && coreLoader != null && (visited == null || visited.add(coreLoader))) {
+      return actionWithClassloader.execute(name, coreLoader, parameter);
     }
 
     return null;
@@ -381,14 +386,14 @@ public final class PluginClassLoader extends UrlClassLoader implements PluginAwa
 
   @SuppressWarnings("UnusedDeclaration")
   public void addLibDirectories(@NotNull Collection<String> libDirectories) {
-    myLibDirectories.addAll(libDirectories);
+    this.libDirectories.addAll(libDirectories);
   }
 
   @Override
   protected String findLibrary(String libName) {
-    if (!myLibDirectories.isEmpty()) {
+    if (!libDirectories.isEmpty()) {
       String libFileName = System.mapLibraryName(libName);
-      ListIterator<String> i = myLibDirectories.listIterator(myLibDirectories.size());
+      ListIterator<String> i = libDirectories.listIterator(libDirectories.size());
       while (i.hasPrevious()) {
         File libFile = new File(i.previous(), libFileName);
         if (libFile.exists()) {
@@ -406,12 +411,12 @@ public final class PluginClassLoader extends UrlClassLoader implements PluginAwa
 
   @Override
   public @NotNull PluginDescriptor getPluginDescriptor() {
-    return myPluginDescriptor;
+    return pluginDescriptor;
   }
 
   @Override
   public String toString() {
-    return "PluginClassLoader[" + myPluginDescriptor + "] " + super.toString();
+    return "PluginClassLoader[" + pluginDescriptor + "] " + super.toString();
   }
 
   private static final class DeepEnumeration implements Enumeration<URL> {
@@ -447,19 +452,19 @@ public final class PluginClassLoader extends UrlClassLoader implements PluginAwa
   @ApiStatus.Internal
   public @NotNull List<ClassLoader> _getParents() {
     //noinspection SSBasedInspection
-    return Collections.unmodifiableList(Arrays.asList(myParents));
+    return Collections.unmodifiableList(Arrays.asList(parents));
   }
 
   @ApiStatus.Internal
   public void attachParent(@NotNull ClassLoader classLoader) {
-    myParents = ArrayUtil.append(myParents, classLoader);
+    parents = ArrayUtil.append(parents, classLoader);
   }
 
   @ApiStatus.Internal
   public boolean detachParent(@NotNull ClassLoader classLoader) {
-    int oldSize = myParents.length;
-    myParents = ArrayUtil.remove(myParents, classLoader);
-    return myParents.length == oldSize - 1;
+    int oldSize = parents.length;
+    parents = ArrayUtil.remove(parents, classLoader);
+    return parents.length == oldSize - 1;
   }
 
   @Override