[testing] [eclipse] [#2413] Eclipse tests now more expansive

We now test generating a level2-DOM from our level1-AST (eclipse has 3 levels of ASTs, more or less), only if
that is possible, i.e. only if the full eclipse is available. This requires using a test target named `eclipse-X`, and not
one of the `ecjX` ones. This is the change that requires the massive update to the build system. About 6 tests,
including a newly added one about @Delegate, now fail. These failures would usually not cause instant failure in
eclipse, but can cause errors during save actions and will likely mess with other things in weird ways, such as
messing up syntax highlighting.

Yes, this commit now makes a bunch of cases fail the unit tests, but that is representative of actual errors in lombok,
so I'm checking it in as is (without this commit, the problem is still there, the tests are just incapable of detecting it).

1 files changed, 76 insertions, 3 deletions

diff --git a/test/core/src/lombok/RunTestsViaEcj.java b/test/core/src/lombok/RunTestsViaEcj.java
index ab28cb0c..739d6316 100644
--- a/test/core/src/lombok/RunTestsViaEcj.java
+++ b/test/core/src/lombok/RunTestsViaEcj.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2014 The Project Lombok Authors.
+ * Copyright (C) 2010-2020 The Project Lombok Authors.
  * 
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -23,25 +23,33 @@ package lombok;
 
 import java.io.File;
 import java.io.StringWriter;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Enumeration;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicReference;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
 
 import lombok.eclipse.Eclipse;
 import lombok.javac.CapturingDiagnosticListener.CompilerMessage;
 
+import org.eclipse.jdt.core.JavaCore;
 import org.eclipse.jdt.core.compiler.CategorizedProblem;
+import org.eclipse.jdt.core.dom.AST;
+import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jdt.internal.compiler.CompilationResult;
 import org.eclipse.jdt.internal.compiler.Compiler;
 import org.eclipse.jdt.internal.compiler.ICompilerRequestor;
 import org.eclipse.jdt.internal.compiler.IErrorHandlingPolicy;
 import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
-import org.eclipse.jdt.internal.compiler.batch.CompilationUnit;
 import org.eclipse.jdt.internal.compiler.batch.FileSystem;
 import org.eclipse.jdt.internal.compiler.env.ICompilationUnit;
 import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
@@ -103,7 +111,8 @@ public class RunTestsViaEcj extends AbstractRunTests {
 		};
 		
 		String source = readFile(file);
-		final CompilationUnit sourceUnit = new CompilationUnit(source.toCharArray(), file.getName(), encoding == null ? "UTF-8" : encoding);
+		char[] sourceArray = source.toCharArray();
+		final org.eclipse.jdt.internal.compiler.batch.CompilationUnit sourceUnit = new org.eclipse.jdt.internal.compiler.batch.CompilationUnit(sourceArray, file.getName(), encoding == null ? "UTF-8" : encoding);
 		
 		Compiler ecjCompiler = new Compiler(createFileSystem(file, minVersion), ecjErrorHandlingPolicy(), ecjCompilerOptions(), bitbucketRequestor, new DefaultProblemFactory(Locale.ENGLISH)) {
 			@Override protected synchronized void addCompilationUnit(ICompilationUnit inUnit, CompilationUnitDeclaration parsedUnit) {
@@ -126,11 +135,75 @@ public class RunTestsViaEcj extends AbstractRunTests {
 		if (cud == null) result.append("---- No CompilationUnit provided by ecj ----");
 		else result.append(cud.toString());
 		
+		if (eclipseAvailable()) {
+			EclipseDomConversion.toDomAst(cud, sourceArray);
+		}
+		
+		return true;
+	}
+	
+	private boolean eclipseAvailable() {
+		try {
+			Class.forName("org.eclipse.jdt.core.dom.CompilationUnit");
+		} catch (Throwable t) {
+			return false;
+		}
+		
 		return true;
 	}
 	
 	private static final String bootRuntimePath = System.getProperty("delombok.bootclasspath");
 	
+	private static class EclipseDomConversion {
+		static CompilationUnit toDomAst(CompilationUnitDeclaration cud, final char[] source) {
+			Map<String, String> options = new HashMap<String, String>();
+			options.put(JavaCore.COMPILER_SOURCE, "11");
+			options.put("org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures", "enabled");
+			try {
+				org.eclipse.jdt.internal.core.CompilationUnit ccu = new org.eclipse.jdt.internal.core.CompilationUnit(null, null, null) {
+					@Override public char[] getContents() {
+						return source;
+					}
+				};
+				return AST.convertCompilationUnit(4, cud, options, false, ccu, 0, null);
+			} catch (SecurityException e) {
+				try {
+					debugClasspathConflicts("org/eclipse/jdt/internal/compiler");
+				} catch (Exception e2) {
+					throw Lombok.sneakyThrow(e2);
+				}
+				throw e;
+			}
+		}
+	}
+	
+	@SuppressWarnings({"all"})
+	private static void debugClasspathConflicts(String prefixToLookFor) throws Exception {
+		String[] paths = System.getProperty("java.class.path").split(":");
+		for (String p : paths) {
+			Path cp = Paths.get(p);
+			if (Files.isDirectory(cp)) {
+				if (Files.isDirectory(cp.resolve(prefixToLookFor))) System.out.println("** DIR-BASED: " + cp);
+			} else if (Files.isRegularFile(cp)) {
+				JarFile jf = new JarFile(cp.toFile());
+				try {
+					Enumeration<JarEntry> jes = jf.entries();
+					while (jes.hasMoreElements()) {
+						JarEntry je = jes.nextElement();
+						if (je.getName().startsWith(prefixToLookFor)) {
+							System.out.println("** JAR-BASED: " + cp);
+							break;
+						}
+					}
+				} finally {
+					jf.close();
+				}
+			} else {
+				System.out.println("** MISSING: " + cp);
+			}
+		}
+	}
+	
 	private FileSystem createFileSystem(File file, int minVersion) {
 		List<String> classpath = new ArrayList<String>();
 		for (Iterator<String> i = classpath.iterator(); i.hasNext();) {