gt:                 result = loader.loadPlugin(file);
context: package org.bukkit.plugin;
  
  
  import com.destroystokyo.paper.event.server.ServerExceptionEvent;
  import com.destroystokyo.paper.exception.ServerEventException;
  import com.destroystokyo.paper.exception.ServerPluginEnableDisableException;
  import com.google.common.collect.ImmutableSet;
  import org.apache.commons.lang3.Validate;
  import org.bukkit.Server;
  import org.bukkit.command.Command;
  import org.bukkit.command.PluginCommandYamlParser;
  import org.bukkit.command.SimpleCommandMap;
  import org.bukkit.event.Event;
  import org.bukkit.event.EventPriority;
  import org.bukkit.event.HandlerList;
  import org.bukkit.event.Listener;
  import org.bukkit.permissions.Permissible;
  import org.bukkit.permissions.Permission;
  import org.bukkit.permissions.PermissionDefault;
  import org.bukkit.util.FileUtil;
  
  import java.io.File;
  import java.lang.reflect.Constructor;
  import java.lang.reflect.Method;
  import java.net.MalformedURLException;
  import java.net.URL;
  import java.util.*;
  import java.util.logging.Level;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  /**
   * Handles all plugin management from the Server
   */
  public final class SimplePluginManager implements PluginManager {
      private final Server server;
      private final Map<Pattern, PluginLoader> fileAssociations = new HashMap<Pattern, PluginLoader>();
      private final List<Plugin> plugins = new ArrayList<Plugin>();
      private final Map<String, Plugin> lookupNames = new HashMap<String, Plugin>();
      private static File updateDirectory = null;
      private final SimpleCommandMap commandMap;
      private final Map<String, Permission> permissions = new HashMap<String, Permission>();
      private final Map<Boolean, Set<Permission>> defaultPerms = new LinkedHashMap<Boolean, Set<Permission>>();
      private final Map<String, Map<Permissible, Boolean>> permSubs = new HashMap<String, Map<Permissible, Boolean>>();
      private final Map<Boolean, Map<Permissible, Boolean>> defSubs = new HashMap<Boolean, Map<Permissible, Boolean>>();
      private boolean useTimings = false;
      private Collection<URL> ignoreURLs = null;
  
      public SimplePluginManager(Server instance, SimpleCommandMap commandMap) {
          server = instance;
          this.commandMap = commandMap;
  
          defaultPerms.put(true, new HashSet<Permission>());
          defaultPerms.put(false, new HashSet<Permission>());
      }
  
      /**
       * Registers the specified plugin loader
       *
       * @param loader Class name of the PluginLoader to register
       * @throws IllegalArgumentException Thrown when the given Class is not a
       *     valid PluginLoader
       */
      public void registerInterface(Class<? extends PluginLoader> loader) throws IllegalArgumentException {
          PluginLoader instance;
  
          if (PluginLoader.class.isAssignableFrom(loader)) {
              Constructor<? extends PluginLoader> constructor;
  
              try {
                  constructor = loader.getConstructor(Server.class);
                  instance = constructor.newInstance(server);
              } catch (NoSuchMethodException ex) {
                  String className = loader.getName();
  
                  throw new IllegalArgumentException(String.format("Class %s does not have a public %s(Server) constructor", className, className), ex);
              } catch (Exception ex) {
                  throw new IllegalArgumentException(String.format("Unexpected exception %s while attempting to construct a new instance of %s", ex.getClass().getName(), loader.getName()), ex);
              }
          } else {
              throw new IllegalArgumentException(String.format("Class %s does not implement interface PluginLoader", loader.getName()));
          }
  
          Pattern[] patterns = instance.getPluginFileFilters();
  
          synchronized (this) {
              for (Pattern pattern : patterns) {
                  fileAssociations.put(pattern, instance);
              }
          }
      }
  
      public void setIgnoreURLs(Collection<URL> urls) {
          this.ignoreURLs = urls;
      }
  
      /**
       * Loads the plugins contained within the specified directory
       *
       * @param directory Directory to check for plugins
       * @return A list of all plugins loaded
       */
      public Plugin[] loadPlugins(File directory) {
          Validate.notNull(directory, "Directory cannot be null");
          Validate.isTrue(directory.isDirectory(), "Directory must be a directory");
  
          if (!(server.getUpdateFolder().equals(""))) {
              updateDirectory = new File(directory, server.getUpdateFolder());
          }
  
          return this.loadPlugins(directory.listFiles(), directory.getPath());
      }
  
      /**
       * Loads the array of plugins
       *
       * @param files Array of plugin files to load
       * @param sourceFolder Containing folder path name string for error messages
       * @return A list of all plugins loaded
       */
      public Plugin[] loadPlugins(File[] files, String sourceFolder) {
          List<Plugin> result = new ArrayList<Plugin>();
          Set<Pattern> filters = fileAssociations.keySet();
  
  
          Map<String, File> plugins = new HashMap<String, File>();
          Set<String> loadedPlugins = new HashSet<String>();
          Map<String, Collection<String>> dependencies = new HashMap<String, Collection<String>>();
          Map<String, Collection<String>> softDependencies = new HashMap<String, Collection<String>>();
  
          // This is where it figures out all possible plugins
          for (File file : files) {
  
              // Skip plugins in the ignore set
              try {
                  URL url = file.toURI().toURL();
                  if (ignoreURLs != null && ignoreURLs.contains(file.toURI().toURL())) {
                      continue;
                  }
              } catch (MalformedURLException ex) {
                  // ignore
              }
  
              PluginLoader loader = null;
              for (Pattern filter : filters) {
                  Matcher match = filter.matcher(file.getName());
                  if (match.find()) {
                      loader = fileAssociations.get(filter);
                  }
              }
  
              if (loader == null) continue;
  
              PluginDescriptionFile description = null;
              try {
                  description = loader.getPluginDescription(file);
                  String name = description.getName();
                  if (name.equalsIgnoreCase("bukkit") || name.equalsIgnoreCase("minecraft") || name.equalsIgnoreCase("mojang")) {
                      server.getLogger().log(Level.SEVERE, "Could not load '" + file.getPath() + "' in folder '" + sourceFolder + "': Restricted Name");
                      continue;
                  } else if (description.rawName.indexOf(' ') != -1) {
                      server.getLogger().warning(String.format(
                          "Plugin `%s' uses the space-character (0x20) in its name `%s' - this is discouraged",
                          description.getFullName(),
                          description.rawName
                          ));
                  }
              } catch (InvalidDescriptionException ex) {
                  server.getLogger().log(Level.SEVERE, "Could not load '" + file.getPath() + "' in folder '" + sourceFolder + "'", ex);
                  continue;
              }
  
              File replacedFile = plugins.put(description.getName(), file);
              if (replacedFile != null) {
                  server.getLogger().severe(String.format(
                      "Ambiguous plugin name `%s' for files `%s' and `%s' in `%s'",
                      description.getName(),
                      file.getPath(),
                      replacedFile.getPath(),
                      sourceFolder
                      ));
              }
  
              Collection<String> softDependencySet = description.getSoftDepend();
              if (softDependencySet != null && !softDependencySet.isEmpty()) {
                  if (softDependencies.containsKey(description.getName())) {
                      // Duplicates do not matter, they will be removed together if applicable
                      softDependencies.get(description.getName()).addAll(softDependencySet);
                  } else {
                      softDependencies.put(description.getName(), new LinkedList<String>(softDependencySet));
                  }
              }
  
              Collection<String> dependencySet = description.getDepend();
              if (dependencySet != null && !dependencySet.isEmpty()) {
                  dependencies.put(description.getName(), new LinkedList<String>(dependencySet));
              }
  
              Collection<String> loadBeforeSet = description.getLoadBefore();
              if (loadBeforeSet != null && !loadBeforeSet.isEmpty()) {
                  for (String loadBeforeTarget : loadBeforeSet) {
                      if (softDependencies.containsKey(loadBeforeTarget)) {
                          softDependencies.get(loadBeforeTarget).add(description.getName());
                      } else {
                          // softDependencies is never iterated, so 'ghost' plugins aren't an issue
                          Collection<String> shortSoftDependency = new LinkedList<String>();
                          shortSoftDependency.add(description.getName());
                          softDependencies.put(loadBeforeTarget, shortSoftDependency);
                      }
                  }
              }
          }
  
          while (!plugins.isEmpty()) {
              boolean missingDependency = true;
              Iterator<String> pluginIterator = plugins.keySet().iterator();
  
              while (pluginIterator.hasNext()) {
                  String plugin = pluginIterator.next();
  
                  if (dependencies.containsKey(plugin)) {
                      Iterator<String> dependencyIterator = dependencies.get(plugin).iterator();
  
                      while (dependencyIterator.hasNext()) {
                          String dependency = dependencyIterator.next();
  
                          // Dependency loaded
                          if (loadedPlugins.contains(dependency)) {
                              dependencyIterator.remove();
  
                          // We have a dependency not found
                          } else if (!plugins.containsKey(dependency)) {
                              missingDependency = false;
                              File file = plugins.get(plugin);
                              pluginIterator.remove();
                              softDependencies.remove(plugin);
                              dependencies.remove(plugin);
  
                              server.getLogger().log(
                                  Level.SEVERE,
                                  "Could not load '" + file.getPath() + "' in folder '" + sourceFolder + "'",
                                  new UnknownDependencyException(dependency));
                              break;
                          }
                      }
  
                      if (dependencies.containsKey(plugin) && dependencies.get(plugin).isEmpty()) {
                          dependencies.remove(plugin);
                      }
                  }
                  if (softDependencies.containsKey(plugin)) {
                      Iterator<String> softDependencyIterator = softDependencies.get(plugin).iterator();
  
                      while (softDependencyIterator.hasNext()) {
                          String softDependency = softDependencyIterator.next();
  
                          // Soft depend is no longer around
                          if (!plugins.containsKey(softDependency)) {
                              softDependencyIterator.remove();
                          }
                      }
  
                      if (softDependencies.get(plugin).isEmpty()) {
                          softDependencies.remove(plugin);
                      }
                  }
                  if (!(dependencies.containsKey(plugin) || softDependencies.containsKey(plugin)) && plugins.containsKey(plugin)) {
                      // We're clear to load, no more soft or hard dependencies left
                      File file = plugins.get(plugin);
                      pluginIterator.remove();
                      missingDependency = false;
  
                      try {
                          result.add(loadPlugin(file));
                          loadedPlugins.add(plugin);
                          continue;
                      } catch (InvalidPluginException ex) {
                          server.getLogger().log(Level.SEVERE, "Could not load '" + file.getPath() + "' in folder '" + sourceFolder + "'", ex);
                      }
                  }
              }
  
              if (missingDependency) {
                  // We now iterate over plugins until something loads
                  // This loop will ignore soft dependencies
                  pluginIterator = plugins.keySet().iterator();
  
                  while (pluginIterator.hasNext()) {
                      String plugin = pluginIterator.next();
  
                      if (!dependencies.containsKey(plugin)) {
                          softDependencies.remove(plugin);
                          missingDependency = false;
                          File file = plugins.get(plugin);
                          pluginIterator.remove();
  
                          try {
                              result.add(loadPlugin(file));
                              loadedPlugins.add(plugin);
                              break;
                          } catch (InvalidPluginException ex) {
                              server.getLogger().log(Level.SEVERE, "Could not load '" + file.getPath() + "' in folder '" + sourceFolder + "'", ex);
                          }
                      }
                  }
                  // We have no plugins left without a depend
                  if (missingDependency) {
                      softDependencies.clear();
                      dependencies.clear();
                      Iterator<File> failedPluginIterator = plugins.values().iterator();
  
                      while (failedPluginIterator.hasNext()) {
                          File file = failedPluginIterator.next();
                          failedPluginIterator.remove();
                          server.getLogger().log(Level.SEVERE, "Could not load '" + file.getPath() + "' in folder '" + sourceFolder + "': circular dependency detected");
                      }
                  }
              }
          }
  
          org.bukkit.command.defaults.TimingsCommand.timingStart = System.nanoTime(); // Spigot
          return result.toArray(new Plugin[result.size()]);
      }
  
      /**
       * Loads the plugin in the specified file
       * <p>
       * File must be valid according to the current enabled Plugin interfaces
       *
       * @param file File containing the plugin to load
       * @return The Plugin loaded, or null if it was invalid
       * @throws InvalidPluginException Thrown when the specified file is not a
       *     valid plugin
       * @throws UnknownDependencyException If a required dependency could not
       *     be found
       */
      public synchronized Plugin loadPlugin(File file) throws InvalidPluginException, UnknownDependencyException {
          Validate.notNull(file, "File cannot be null");
  
          checkUpdate(file);
  
          Set<Pattern> filters = fileAssociations.keySet();
          Plugin result = null;
  
          for (Pattern filter : filters) {
              String name = file.getName();
              Matcher match = filter.matcher(name);
  
              if (match.find()) {
                  PluginLoader loader = fileAssociations.get(filter);
  
  