Let PDE compute required packages using a CompilationParticipant

There are some case where the JDT concept of classpath restrictions do
not match well the OSGi runtime handling of imported packages these
include:

- inlined constants are never visible at runtime and therefore no import
required and no restriction issue
- indirect references through super types are handled by the classpath
of the providing bundle and not the consumer
- methods inherited from superclasses are also not a problem at all

This is now a radical change in how PDE handles the case and detects
problems:

- instead of using access restrictions that try to emulate the runtime
behavior, it computes a full set of transitive classpath items and add
them unrestricted (except for internal packages to get warnings there)
- then during compilation we dynamically compute the actual set of
required imports at runtime
- if any of these imports are missing in the manifest we create a
problem and suggest suitable quickfix

This has the benefit that we are in full control over what is detected,
how it is reported and where it is reported. It also gives much more
flexibility in improving user experience, for example one might even
want to have some "autoimport" feature that is adding /removing packages
on demand so do not bother the user with doing this daunting task
manually.

Author: laeubi

ui/org.eclipse.pde.core/plugin.xml

@@ -439,4 +439,12 @@
                  type="Repository">
            </targetLocation>
         </extension>
+        <extension
+              point="org.eclipse.jdt.core.compilationParticipant">
+           <compilationParticipant
+                 class="org.eclipse.pde.internal.core.builders.PDECompilationParticipant"
+                 id="org.eclipse.pde.core.compilationParticipant"
+                 modifiesEnvironment="false">
+           </compilationParticipant>
+        </extension>
 </plugin>

ui/org.eclipse.pde.core/src/org/eclipse/pde/internal/core/builders/PDECompilationParticipant.java

@@ -0,0 +1,112 @@
+package org.eclipse.pde.internal.core.builders;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.compiler.BuildContext;
+import org.eclipse.jdt.core.compiler.CompilationParticipant;
+import org.eclipse.pde.internal.core.bnd.PdeProjectAnalyzer;
+import org.eclipse.pde.internal.core.natures.PluginProject;
+
+import aQute.bnd.osgi.Analyzer;
+import aQute.bnd.osgi.Descriptors.PackageRef;
+import aQute.bnd.osgi.EmbeddedResource;
+import aQute.bnd.osgi.Packages;
+
+public class PDECompilationParticipant extends CompilationParticipant {
+
+
+	private ThreadLocal<IJavaProject> project = new ThreadLocal<>();
+	private ThreadLocal<Analyzer> analyzer = new ThreadLocal<>();
+
+	@Override
+	public int aboutToBuild(IJavaProject project) {
+		this.project.set(project);
+		System.out.println(
+				String.format("---- PDECompilationParticipant.aboutToBuild(%s)", project.getProject().getName())); //$NON-NLS-1$
+		return READY_FOR_BUILD;
+	}
+
+	@Override
+	public void buildFinished(IJavaProject project) {
+		System.out.println(
+				String.format("---- PDECompilationParticipant.buildFinished(%s)", project.getProject().getName())); //$NON-NLS-1$
+		this.project.set(null);
+		try (Analyzer analyzer = this.analyzer.get()) {
+			if (analyzer != null) {
+				try {
+					analyzer.setImportPackage("*"); //$NON-NLS-1$
+					analyzer.calcManifest();
+					Packages imports = analyzer.getImports();
+					if (imports == null) {
+						System.out.println("No packages computed!");
+					} else {
+						Set<String> computedPackages = imports.keySet().stream().map(PackageRef::getFQN)
+								.collect(Collectors.toSet());
+						for (String pkg : computedPackages) {
+							System.out.println("  - " + pkg);
+						}
+					}
+				} catch (Exception e) {
+					e.printStackTrace();
+				}
+			}
+		} catch (IOException e) {
+		}
+		this.analyzer.set(null);
+	}
+
+	@Override
+	public void buildStarting(BuildContext[] files, boolean isBatch) {
+		IJavaProject javaProject = project.get();
+		System.out.println(
+				String.format("PDECompilationParticipant.buildStarting(%s)", javaProject.getProject().getName())); //$NON-NLS-1$
+		try {
+			this.analyzer.set(new PdeProjectAnalyzer(javaProject.getProject(), true));
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	@Override
+	public void cleanStarting(IJavaProject project) {
+		System.out.println(
+				String.format("---- PDECompilationParticipant.cleanStarting(%s)", project.getProject().getName())); //$NON-NLS-1$
+	}
+
+	@Override
+	public boolean isActive(IJavaProject project) {
+		System.out.println(String.format("PDECompilationParticipant.isActive(%s)", project.getProject().getName())); //$NON-NLS-1$
+		return PluginProject.isPluginProject(project.getProject());
+	}
+
+	@Override
+	public boolean isPostProcessor() {
+		return true;
+	}
+
+	@Override
+	public Optional<byte[]> postProcess(BuildContext file, ByteArrayInputStream bytes) {
+		IJavaProject javaProject = project.get();
+		Analyzer projectAnalyzer = analyzer.get();
+		IPath projectRelativePath = file.getFile().getProjectRelativePath();
+		String relativePath = projectRelativePath.toString();
+		String base = relativePath.substring(javaProject.getProject().getProjectRelativePath().toString().length());
+		System.out.println(String.format("PDECompilationParticipant.postProcess(%s)", file.getFile())); //$NON-NLS-1$
+		if (base.startsWith("src/")) {
+			// TODO build context should supply the binary name
+			base = base.substring("src/".length());
+		}
+		String name = base.replace(".java", ".class");
+		System.out.println(base);
+		projectAnalyzer.getJar().putResource(name,
+				new EmbeddedResource(bytes.readAllBytes(), System.currentTimeMillis()));
+		return super.postProcess(file, bytes);
+	}
+
+}