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

@@ -50,7 +50,9 @@
 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.util.NLS;
 import org.eclipse.pde.core.plugin.IMatchRules;
 import org.eclipse.pde.core.plugin.IPluginBase;
@@ -59,10 +61,12 @@
 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;
 import org.eclipse.pde.internal.core.PDECore;
+import org.eclipse.pde.internal.core.PluginModelManager;
 import org.eclipse.pde.internal.core.TargetPlatformHelper;
 import org.eclipse.pde.internal.core.ifeature.IFeature;
 import org.eclipse.pde.internal.core.ifeature.IFeatureChild;
@@ -75,7 +79,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 +169,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) //
 				.forEach(p -> addDefaultStartingBundle(bundle2startLevel, p));
 	}
 
@@ -228,11 +226,7 @@ private static Map<IPluginModelBase, String> getMergedBundleMapFeatureBased(ILau
 			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).forEach(launchPlugins::add);
 		}
 
 		// Create the start levels for the selected plugins and add them to the map
@@ -546,6 +540,76 @@ 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) {
+		if (includedPlugins.isEmpty()) {
+			return Stream.empty();
+		}
+		// Create and resolve the new 'launch'-state where bundles explicitly included in the launch are preferred. Then compute the requirement closure on that 'launch'-state.
+		Map<BundleDescription, IPluginModelBase> launchBundlePlugins = new HashMap<>(includedPlugins.size() * 4 / 3 + 1);
+		Set<BundleDescription> launchBundles = reresolveBundlesPreferringIncludedBundles(includedPlugins, launchBundlePlugins);
+		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(launchBundlePlugins::get).map(Objects::requireNonNull) //
+				.filter(p -> !includedPlugins.contains(p));
+	}
+
+	private static Set<BundleDescription> reresolveBundlesPreferringIncludedBundles(Set<IPluginModelBase> includedPlugins, Map<BundleDescription, IPluginModelBase> launchBundlePlugins) {
+		PluginModelManager modelManager = PDECore.getDefault().getModelManager();
+		State tpState = modelManager.getState().getState();
+
+		State launchState = BundleHelper.getPlatformAdmin().getFactory().createState(true);
+		launchState.setPlatformProperties(tpState.getPlatformProperties());
+
+		// Collect all bundles explicitly included in the launch
+		for (IPluginModelBase plugin : includedPlugins) {
+			addPluginBundle(plugin, launchState, launchBundlePlugins, tpState);
+		}
+		Set<BundleDescription> launchBundles = new HashSet<>(launchBundlePlugins.keySet());
+
+		// Iterate workspace- and TP-models separately to avoid shadowing of TP models by workspace models
+		Stream.of(modelManager.getWorkspaceModels(), modelManager.getExternalModels()).flatMap(Arrays::stream) //
+				.filter(IPluginModelBase::isEnabled).filter(p -> !includedPlugins.contains(p)) //
+				.forEach(plugin -> addPluginBundle(plugin, launchState, launchBundlePlugins, tpState));
+
+		launchState.getResolver().setSelectionPolicy(Comparator
+				// prefer explicitly directly included in the launch 
+				.comparing((BaseDescription d) -> !launchBundles.contains(d.getSupplier())) //false<true
+				.thenComparing(tpState.getResolver().getSelectionPolicy()));
+
+		launchState.resolve(false);
+		return launchBundles;
+	}
+
+	private static void addPluginBundle(IPluginModelBase plugin, State launchState, Map<BundleDescription, IPluginModelBase> launchBundlePlugin, State tpState) {
+		BundleDescription bundle = plugin.getBundleDescription();
+		if (bundle != null) {
+			if (bundle.getContainingState() != tpState) { // consistency check
+				throw new IllegalStateException("Plugins have different TP state"); //$NON-NLS-1$
+			}
+			BundleDescription launchBundle = launchState.getFactory().createBundleDescription(bundle);
+			if (!launchState.addBundle(launchBundle)) {
+				throw new IllegalStateException("Failed to add bundle to launch state: " + launchBundle); //$NON-NLS-1$
+			}
+			if (launchBundlePlugin.put(launchBundle, plugin) != null) {
+				throw new IllegalStateException("Duplicated launch bundle for plugin: " + plugin); //$NON-NLS-1$
+			}
+		}
+	}
+
+	// -- start data ---
+
 	public static String getStartData(BundleDescription desc, String defaultStartData) {
 		String runLevel = resolveSystemRunLevelText(desc);
 		String auto = resolveSystemAutoText(desc);