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

@@ -244,7 +244,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,8 +28,10 @@
 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.Dictionary;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
@@ -51,6 +53,8 @@
 import org.eclipse.debug.core.ILaunchConfiguration;
 import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
 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) //
+		computeDependencyClosure0(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
-			}
+			computeDependencyClosure0(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,83 @@ private static void addBundleToMap(Map<IPluginModelBase, String> map, IPluginMod
 		map.put(bundle, startData);
 	}
 
+	// --- dependency resolution ---
+
+	private static Stream<IPluginModelBase> computeDependencyClosure0(Set<IPluginModelBase> includedPlugins, boolean includeOptional, String defaultPluginResolution) {
+		DependencyManager.Options[] options = includeOptional //
+				? new DependencyManager.Options[] {DependencyManager.Options.INCLUDE_OPTIONAL_DEPENDENCIES}
+				: new DependencyManager.Options[] {};
+		if (includedPlugins.isEmpty()) {
+			return Stream.empty();
+		}
+		Set<BundleDescription> initialLaunchBundles = createNewState(includedPlugins, defaultPluginResolution).keySet();
+		State launchState = initialLaunchBundles.iterator().next().getContainingState();
+		Set<BundleDescription> bundles = new HashSet<>(initialLaunchBundles);
+		DependencyManager.getImplicitDependencies().stream().map(descriptor -> {
+			String versionStr = descriptor.getVersion();
+			Version version = versionStr != null ? Version.parseVersion(versionStr) : null;
+			return launchState.getBundle(descriptor.getId(), version);
+		}).forEach(bundles::add);
+
+		Set<BundleDescription> closure = DependencyManager.findRequirementsClosure(bundles, options);
+		return closure.stream() //
+				.map(bundle -> {
+					// Ensure that the preferred plugin-location is respected (therefore not just use PluginRegistry.findModel)
+					//TODO: incooporate 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 Map<BundleDescription, IPluginModelBase> createNewState(Collection<IPluginModelBase> initialPlugins, String defaultPluginResolution) {
+		StateObjectFactory factory = BundleHelper.getPlatformAdmin().getFactory();
+		IPluginModelBase any = initialPlugins.iterator().next();
+		// The state is the same as TargetPlatformHelper.getState()
+		State tpState = any.getBundleDescription().getContainingState();
+		Set<BundleDescription> initialBundles = new HashSet<>();
+		State launchState = factory.createState(true);
+		Map<BundleDescription, IPluginModelBase> launchBundle2plugin = new HashMap<>();
+		for (IPluginModelBase plugin : initialPlugins) {
+			BundleDescription bundle = plugin.getBundleDescription();
+			if (bundle != null) {
+				if (bundle.getContainingState() != tpState) {
+					throw new IllegalStateException("Plugins have different TP state"); //$NON-NLS-1$
+				}
+				initialBundles.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 (launchBundle2plugin.put(launchBundle, plugin) != null) {
+					throw new IllegalStateException("Duplicated launch bundle for plugin: " + plugin); //$NON-NLS-1$
+				}
+			}
+		}
+		// Add all other bundles from tpState later to ensure that the initial plugins are preferd.
+		//TODO: check how this is ensured?! Maybe resolve inbeteen, which is probably incomplete?
+		BundleDescription[] bundles = tpState.getBundles();
+		//TODO: or use PluginRegistry.getAllModels(); and check compare against the initialPlugins. But this has different semantic
+		for (BundleDescription bundle : bundles) {
+			if (!initialBundles.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$
+				}
+//				IPluginModelBase plugin = getRequiredPlugin(bundle.getSymbolicName(), bundle.getVersion().toString(), IMatchRules.PERFECT, defaultPluginResolution);
+//				if (launchBundle2plugin.put(launchBundle, plugin) != null) {
+//					throw new IllegalStateException("Duplicated launch bundle for plugin: " + plugin); //$NON-NLS-1$
+//				}
+			}
+		}
+		//TODO: ensure this is correct?!
+		Dictionary<?, ?>[] platformProperties = tpState.getPlatformProperties();
+		launchState.setPlatformProperties(platformProperties);
+		launchState.resolve(false);
+		return launchBundle2plugin;
+	}
+
+	// -- start data ---
+
 	public static String getStartData(BundleDescription desc, String defaultStartData) {
 		String runLevel = resolveSystemRunLevelText(desc);
 		String auto = resolveSystemAutoText(desc);