Prefer explicitly included plugins for Eclipse/OSGi launches

When launching an application create a new Equinox resolver state, where
explicitly included plugins/bundles are preferred and compute the
requirements closure from that state.
This avoids adding other providers of a capability if another provider
is already (explicitly) included in a launch, just because the former is
wired to the requirement in the target-platform state.
Potentially this also makes the set of launched plugins more compact.

Fixes #1604

Author: HannesWell

ui/org.eclipse.pde.core/src/org/eclipse/pde/internal/core/DependencyManager.java

@@ -262,7 +262,7 @@ private static boolean isTestWorkspaceProject(Resource f) {
 	 *
 	 * @return a set of bundle ids
 	 */
-	private static Collection<NameVersionDescriptor> getImplicitDependencies() {
+	public static Collection<NameVersionDescriptor> getImplicitDependencies() {
 		try {
 			ITargetPlatformService service = PDECore.getDefault().acquireService(ITargetPlatformService.class);
 			if (service != null) {

ui/org.eclipse.pde.launching/src/org/eclipse/pde/internal/launching/launcher/BundleLauncherHelper.java

@@ -28,6 +28,7 @@
 import java.util.ArrayDeque;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
@@ -50,7 +51,10 @@
 import org.eclipse.core.runtime.Status;
 import org.eclipse.debug.core.ILaunchConfiguration;
 import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
+import org.eclipse.osgi.service.resolver.BaseDescription;
 import org.eclipse.osgi.service.resolver.BundleDescription;
+import org.eclipse.osgi.service.resolver.State;
+import org.eclipse.osgi.service.resolver.StateObjectFactory;
 import org.eclipse.osgi.util.NLS;
 import org.eclipse.pde.core.plugin.IMatchRules;
 import org.eclipse.pde.core.plugin.IPluginBase;
@@ -59,6 +63,7 @@
 import org.eclipse.pde.core.plugin.PluginRegistry;
 import org.eclipse.pde.core.target.ITargetDefinition;
 import org.eclipse.pde.core.target.ITargetPlatformService;
+import org.eclipse.pde.internal.build.BundleHelper;
 import org.eclipse.pde.internal.build.IPDEBuildConstants;
 import org.eclipse.pde.internal.core.DependencyManager;
 import org.eclipse.pde.internal.core.FeatureModelManager;
@@ -75,7 +80,6 @@
 import org.eclipse.pde.internal.launching.PDEMessages;
 import org.eclipse.pde.launching.IPDELauncherConstants;
 import org.osgi.framework.Version;
-import org.osgi.resource.Resource;
 
 public class BundleLauncherHelper {
 
@@ -166,12 +170,7 @@ private static void addRequiredBundles(Map<IPluginModelBase, String> bundle2star
 		RequirementHelper.addApplicationLaunchRequirements(appRequirements, configuration, bundle2startLevel);
 
 		boolean includeOptional = configuration.getAttribute(IPDELauncherConstants.INCLUDE_OPTIONAL, true);
-		Set<BundleDescription> requiredDependencies = includeOptional //
-				? DependencyManager.getDependencies(bundle2startLevel.keySet(), DependencyManager.Options.INCLUDE_OPTIONAL_DEPENDENCIES)
-				: DependencyManager.getDependencies(bundle2startLevel.keySet());
-
-		requiredDependencies.stream().map(Resource.class::cast) //
-				.map(PluginRegistry::findModel).filter(Objects::nonNull) //
+		computeDependencies(bundle2startLevel.keySet(), includeOptional, IPDELauncherConstants.LOCATION_WORKSPACE) //
 				.forEach(p -> addDefaultStartingBundle(bundle2startLevel, p));
 	}
 
@@ -227,12 +226,8 @@ private static Map<IPluginModelBase, String> getMergedBundleMapFeatureBased(ILau
 			List<String> appRequirements = RequirementHelper.getApplicationLaunchRequirements(configuration);
 			RequirementHelper.addApplicationLaunchRequirements(appRequirements, configuration, launchPlugins, launchPlugins::add);
 
-			// Get all required plugins
-			Set<BundleDescription> additionalBundles = DependencyManager.getDependencies(launchPlugins);
-			for (BundleDescription bundle : additionalBundles) {
-				IPluginModelBase plugin = getRequiredPlugin(bundle.getSymbolicName(), bundle.getVersion().toString(), IMatchRules.PERFECT, defaultPluginResolution);
-				launchPlugins.add(Objects.requireNonNull(plugin));// should never be null
-			}
+			computeDependencies(launchPlugins, false, defaultPluginResolution) //
+					.map(Objects::requireNonNull).forEach(launchPlugins::add);
 		}
 
 		// Create the start levels for the selected plugins and add them to the map
@@ -546,6 +541,107 @@ private static void addBundleToMap(Map<IPluginModelBase, String> map, IPluginMod
 		map.put(bundle, startData);
 	}
 
+	// --- dependency resolution ---
+
+	private static Stream<IPluginModelBase> computeDependencies(Set<IPluginModelBase> includedPlugins, boolean includeOptional, String defaultPluginResolution) {
+		if (includedPlugins.isEmpty()) {
+			return Stream.empty();
+		}
+		Set<BundleDescription> launchBundles = resolveBundlesInNewStatePreferringIncludedBundles(includedPlugins, defaultPluginResolution);
+		State launchState = launchBundles.iterator().next().getContainingState();
+
+		DependencyManager.getImplicitDependencies().stream().map(descriptor -> {
+			String versionStr = descriptor.getVersion();
+			Version version = versionStr != null ? Version.parseVersion(versionStr) : null;
+			return launchState.getBundle(descriptor.getId(), version);
+		}).forEach(launchBundles::add);
+
+		DependencyManager.Options[] options = includeOptional //
+				? new DependencyManager.Options[] {DependencyManager.Options.INCLUDE_OPTIONAL_DEPENDENCIES}
+				: new DependencyManager.Options[] {};
+		Set<BundleDescription> closure = DependencyManager.findRequirementsClosure(launchBundles, options);
+		return closure.stream() //
+				.map(bundle -> {
+					// Ensure that the preferred plugin-location is respected (therefore not just use PluginRegistry.findModel)
+					//TODO: incorporate this when creating the new state?!
+					return getRequiredPlugin(bundle.getSymbolicName(), bundle.getVersion().toString(), IMatchRules.PERFECT, defaultPluginResolution);
+				}).map(Objects::requireNonNull) //TODO: check if this can ever be null?!
+				.filter(p -> !includedPlugins.contains(p));
+	}
+
+	private static Set<BundleDescription> resolveBundlesInNewStatePreferringIncludedBundles(Collection<IPluginModelBase> includedPlugins, String defaultPluginResolution) {
+		Set<BundleDescription> includedTPBundles = new HashSet<>();
+		Set<BundleDescription> launchBundles = new HashSet<>();
+		State tpState = TargetPlatformHelper.getState();
+
+		StateObjectFactory factory = BundleHelper.getPlatformAdmin().getFactory();
+		State launchState = factory.createState(true);
+		//TODO: ensure this is correct?!
+		launchState.setPlatformProperties(tpState.getPlatformProperties());
+
+		Comparator<BaseDescription> selectionPolicy = Comparator.<BaseDescription, Boolean> //
+				comparing(d -> launchBundles.contains(d.getSupplier())).reversed() //false<true
+				.thenComparing(tpState.getResolver().getSelectionPolicy());
+		launchState.getResolver().setSelectionPolicy(selectionPolicy);
+
+		// Collect all bundles explicitly included in the launch
+		for (IPluginModelBase plugin : includedPlugins) {
+			BundleDescription bundle = plugin.getBundleDescription();
+			if (bundle != null) {
+				if (bundle.getContainingState() != tpState) { // consistency check
+					throw new IllegalStateException("Plugins have different TP state"); //$NON-NLS-1$
+				}
+				includedTPBundles.add(bundle);
+				BundleDescription launchBundle = factory.createBundleDescription(bundle);
+				if (!launchState.addBundle(launchBundle)) {
+					throw new IllegalStateException("Failed to add bundle to launch state: " + launchBundle); //$NON-NLS-1$
+				}
+				if (!launchBundles.add(launchBundle)) {
+					throw new IllegalStateException("Duplicated launch bundle for plugin: " + plugin); //$NON-NLS-1$
+				}
+			}
+		}
+		// Add all other bundles from the tpState and resolve the set of explicitly included bundles against them
+		for (BundleDescription bundle : tpState.getBundles()) {
+			if (!includedTPBundles.contains(bundle)) {
+				BundleDescription launchBundle = factory.createBundleDescription(bundle);
+				if (!launchState.addBundle(launchBundle)) {
+					throw new IllegalStateException("Failed to add bundle to launch state: " + launchBundle); //$NON-NLS-1$
+				}
+			}
+		}
+		launchState.resolve(false);
+		return launchBundles;
+	}
+
+	// -- start data ---
+
+//	private static Comparator<BaseDescription> getDefaultSelectionPolicy(Dictionary<?, ?>[] platformProperties) {
+//		Object preferSystem = platformProperties.length == 0 ? null : platformProperties[0].get("osgi.resolver.preferSystemPackages"); //$NON-NLS-1$
+//		boolean preferSystemPackages = preferSystem == null || Boolean.parseBoolean(preferSystem.toString());
+//		String systemBundle = Optional.ofNullable(platformProperties.length == 0 ? null : (String) platformProperties[0].get("osgi.system.bundle")).orElse(EquinoxContainer.NAME); //$NON-NLS-1$
+//
+//		return (BaseDescription d1, BaseDescription d2) -> {
+//			// Assume BaseDescription.getName() == BundleDescription.getSymbolicName()
+//			if (preferSystemPackages) {
+//				if (systemBundle.equals(d1.getSupplier().getSymbolicName()) && !systemBundle.equals(d2.getSupplier().getSymbolicName())) {
+//					return -1;
+//				} else if (!systemBundle.equals(d1.getSupplier().getSymbolicName()) && systemBundle.equals(d2.getSupplier().getSymbolicName())) {
+//					return 1;
+//				}
+//			}
+//			;
+//			if (d1.getSupplier().isResolved() != d2.getSupplier().isResolved()) {
+//				return d1.getSupplier().isResolved() ? -1 : 1;
+//			}
+//			int versionCompare = -(d1.getVersion().compareTo(d2.getVersion()));
+//			if (versionCompare != 0) {
+//				return versionCompare;
+//			}
+//			return Long.compare(d1.getSupplier().getBundleId(), d2.getSupplier().getBundleId());
+//		};
+//	}
+
 	public static String getStartData(BundleDescription desc, String defaultStartData) {
 		String runLevel = resolveSystemRunLevelText(desc);
 		String auto = resolveSystemAutoText(desc);