diff --git a/org.eclipse.jdt.debug.tests/console tests/org/eclipse/jdt/debug/tests/console/JavaStackTraceConsoleTest.java b/org.eclipse.jdt.debug.tests/console tests/org/eclipse/jdt/debug/tests/console/JavaStackTraceConsoleTest.java
index 924dcda..6e3a667 100644
--- a/org.eclipse.jdt.debug.tests/console tests/org/eclipse/jdt/debug/tests/console/JavaStackTraceConsoleTest.java
+++ b/org.eclipse.jdt.debug.tests/console tests/org/eclipse/jdt/debug/tests/console/JavaStackTraceConsoleTest.java
@@ -175,6 +175,17 @@
 		assertArrayEquals("Expected no hyperlinks for invalid type name", new Position[0], positions);
 	}
 
+	public void testBug489365_unicodeMatch() throws Exception {
+		consoleDocumentWithText("at com.example.Fran\u00E7ais.de\u0301butant(Fran\u00E7ais.java:101)\n" // "Latin Small Letter C with Cedilla"
+				+ "at com.example.Franc\u0327ais.de\u0301butant(Franc\u0327ais.java:101)\n" // "Latin Small Letter C" + "Combining Cedilla"
+				+ "at Exc\u00E4ption.main(Exc\u00E4ption.java:4)\n" // "Latin Small Letter A with Diaeresis"
+				+ "at Exca\u0308ption.main(Exca\u0308ption.java:4)"); // "Latin Small Letter A" + "Combining Diaeresis"
+
+		String[] matchTexts = linkTextsAtPositions(34, 88, 126, 163);
+		assertArrayEquals(allLinks(), new String[] { "Fran\u00E7ais.java:101", "Franc\u0327ais.java:101",
+				"Exc\u00E4ption.java:4", "Exca\u0308ption.java:4" }, matchTexts);
+	}
+
 	/**
 	 * Test save/restore of stack trace console content on console close/reactivation.
 	 */
diff --git a/org.eclipse.jdt.debug.tests/java8/EvalTest18.java b/org.eclipse.jdt.debug.tests/java8/EvalTest18.java
index 02e72ba..b7c82cb 100644
--- a/org.eclipse.jdt.debug.tests/java8/EvalTest18.java
+++ b/org.eclipse.jdt.debug.tests/java8/EvalTest18.java
@@ -19,5 +19,17 @@
 	public static void main(String[] args) {
 		List<String> strings = Arrays.asList("One", "Two", "Three");
 		System.out.println("Count of strings in stream from array =" + strings.stream().count());
+		nextMain();
 	}
+	
+	public static void nextMain() {
+		int someInt = 22; List<Integer> l = Arrays.asList(1,2,3,4);
+		
+		System.out.println("Just some int = " + someInt);
+		
+		for (int i : l ) {
+			System.out.println("i = " + i);
+		}
+	}
+	
 }
\ No newline at end of file
diff --git a/org.eclipse.jdt.debug.tests/java8/FunctionalCaptureTest18.java b/org.eclipse.jdt.debug.tests/java8/FunctionalCaptureTest18.java
new file mode 100644
index 0000000..1a35ce4
--- /dev/null
+++ b/org.eclipse.jdt.debug.tests/java8/FunctionalCaptureTest18.java
@@ -0,0 +1,132 @@
+/*******************************************************************************
+ * Copyright (c) 2020 Jesper Steen Møller and others.
+ *
+ * This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *     Jesper Steen Møller - initial API and implementation
+ *******************************************************************************/
+
+import java.util.Objects;
+import java.util.function.Function;
+
+public class FunctionalCaptureTest18 {
+	
+	FunctionalCaptureTest18(int field) {
+		publicField = field;
+	}
+	
+	public static void main(String[] args) {
+		new FunctionalCaptureTest18(1).runAssertions(1);
+	}
+
+	static <I, O> O assertFunctionalExpression(Function<I, O> functional, I input, O expected) {
+		O result = functional.apply(input);
+		if (!Objects.equals(result, expected)) {
+			throw new RuntimeException("Expected " + expected + ", got " + result);
+		}
+		return result;
+	}
+
+	@Override
+	public int hashCode() {
+		return 1992;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj || obj == null)
+			return false;
+		return getClass() == obj.getClass();
+	}
+
+	final public int publicField;
+	private int privateField = 2;
+
+	public static int publicStaticField = 3;
+	private static int privateStaticField = 4;
+
+	public Integer publicMethod() {
+		return 5;
+	}
+	private Integer privateMethod() {
+		return 6;
+	}
+	public int publicArgMethod(int i) {
+		return i + 6;
+	}
+	private int privateArgMethod(int i) {
+		return i + 7;
+	}
+	public static int publicStaticMethod(int i) {
+		return i - 8;
+	}
+	private static int privateStaticMethod(int i) {
+		return i - 9;
+	}
+	
+	public void runAssertions(int parameter /* = 1 */) {
+		int localConstI = -3;
+		System.out.println("Go!");
+		/* CHECK EXPRESSIONS BELOW */
+		/* Nothing captured */
+		assertFunctionalExpression(n -> -3, 42, -3);
+		assertFunctionalExpression(n -> n / 2 - 7, 10, -2);
+
+		/* Capture locals */
+		/* But not yet on project's types */
+		assertFunctionalExpression(n -> n + localConstI, 2, -1);
+		assertFunctionalExpression(n -> n - parameter, parameter, 0);
+
+		/* Capture instance fields */
+		/* But not yet on enclosing instance's instance fields */
+		assertFunctionalExpression(n -> n - publicField, 2, 1);
+		assertFunctionalExpression(n -> n - this.publicField, 2, 1);
+		assertFunctionalExpression(n -> n - privateField, 4, 2);/* SKIP */
+		assertFunctionalExpression(n -> n - this.privateField, 4, 2);/* SKIP */
+		
+		/* Capture static fields */
+		/* But not yet on non-public fields */
+		assertFunctionalExpression(n -> n - publicStaticField, 6, 3);
+		assertFunctionalExpression(n -> n - privateStaticField, 8, 4);/* SKIP */
+
+		/* Evaluate unbound method references */
+		/* But not yet on project's non-public methods */
+		assertFunctionalExpression(FunctionalCaptureTest18::publicMethod, this, 5);
+		assertFunctionalExpression(FunctionalCaptureTest18::privateMethod, this, 6);/* SKIP */
+
+		/* Evaluate instance method references */
+		assertFunctionalExpression("Hello, "::concat, "World", "Hello, World");
+		/* But not yet this-references */
+		assertFunctionalExpression(this::publicArgMethod, 1, 7);
+		assertFunctionalExpression(this::privateArgMethod, 1, 8);/* SKIP */
+
+		/* Evaluate static method references */
+		assertFunctionalExpression(Integer::valueOf, "16", 16);
+		assertFunctionalExpression(FunctionalCaptureTest18::publicStaticMethod, 17, 9);
+		/* But not yet on project's non-public methods */
+		assertFunctionalExpression(FunctionalCaptureTest18::privateStaticMethod, 19, 10);/* SKIP */
+
+		/* Capture methods */
+		assertFunctionalExpression(s -> Integer.valueOf(s, 16), "0B", 11);
+		/* But not yet directlt on the instance */
+		assertFunctionalExpression(obj -> obj.publicMethod() + 7, this, 12);
+		assertFunctionalExpression(obj -> this.publicMethod() + 8, this, 13);
+		assertFunctionalExpression(obj -> publicMethod() + 8, this, 13);
+		assertFunctionalExpression(obj -> obj.privateMethod() + 8, this, 14);/* SKIP */
+		assertFunctionalExpression(obj -> this.privateMethod() + 9, this, 15);/* SKIP */
+		assertFunctionalExpression(obj -> privateMethod() + 9, this, 15);/* SKIP */
+
+		/* Constructor references */
+		assertFunctionalExpression(String::new, new char[] { 'a','b','c' }, "abc");
+		assertFunctionalExpression(FunctionalCaptureTest18::new, 42, new FunctionalCaptureTest18(42));
+
+		/* END OF TESTS */
+		System.out.println("OK");
+	}
+}
diff --git a/org.eclipse.jdt.debug.tests/testprograms/ErrorRecurrence.java b/org.eclipse.jdt.debug.tests/testprograms/ErrorRecurrence.java
new file mode 100644
index 0000000..916db7c
--- /dev/null
+++ b/org.eclipse.jdt.debug.tests/testprograms/ErrorRecurrence.java
@@ -0,0 +1,28 @@
+
+public class ErrorRecurrence {
+
+	public static void main(String[] args) {
+		m0(); // L5
+	}
+	static void m0() {
+		try {
+			m1();
+		} finally {
+			System.out.println("finally");
+		} // L12
+	}
+
+	static void m1() {
+		try {
+			m2();
+		} catch (Error e) {
+			System.out.println("caught");
+			throw e; // L20
+		}
+	}
+
+	static void m2() {
+		System.out.println("before throw");
+		throw new Error(); // L26
+	}
+}
diff --git a/org.eclipse.jdt.debug.tests/tests/org/eclipse/jdt/debug/tests/AbstractDebugTest.java b/org.eclipse.jdt.debug.tests/tests/org/eclipse/jdt/debug/tests/AbstractDebugTest.java
index 9a3e826..9aa6ac1 100644
--- a/org.eclipse.jdt.debug.tests/tests/org/eclipse/jdt/debug/tests/AbstractDebugTest.java
+++ b/org.eclipse.jdt.debug.tests/tests/org/eclipse/jdt/debug/tests/AbstractDebugTest.java
@@ -169,6 +169,7 @@
 import org.osgi.service.prefs.BackingStoreException;
 
 import com.sun.jdi.InternalException;
+import com.sun.jdi.InvocationException;
 
 import junit.framework.TestCase;
 
@@ -204,7 +205,8 @@
 			"org.eclipse.debug.tests.targets.HcrClass5", "org.eclipse.debug.tests.targets.HcrClass6", "org.eclipse.debug.tests.targets.HcrClass7", "org.eclipse.debug.tests.targets.HcrClass8",
 			"org.eclipse.debug.tests.targets.HcrClass9", "TestContributedStepFilterClass", "TerminateAll_01", "TerminateAll_02", "StepResult1",
 			"StepResult2", "StepResult3", "StepUncaught", "TriggerPoint_01", "BulkThreadCreationTest", "MethodExitAndException",
-			"Bug534319earlyStart", "Bug534319lateStart", "Bug534319singleThread", "Bug534319startBetwen", "MethodCall", "Bug538303", "Bug540243", "OutSync", "OutSync2", "ConsoleOutputUmlaut" };
+			"Bug534319earlyStart", "Bug534319lateStart", "Bug534319singleThread", "Bug534319startBetwen", "MethodCall", "Bug538303", "Bug540243",
+			"OutSync", "OutSync2", "ConsoleOutputUmlaut", "ErrorRecurrence" };
 
 	/**
 	 * the default timeout
@@ -456,6 +458,7 @@
 	        if (!loaded18) {
 	        	jp = createProject(ONE_EIGHT_PROJECT_NAME, JavaProjectHelper.TEST_1_8_SRC_DIR.toString(), JavaProjectHelper.JAVA_SE_1_8_EE_NAME, false);
 	    		cfgs.add(createLaunchConfiguration(jp, "EvalTest18"));
+	    		cfgs.add(createLaunchConfiguration(jp, "FunctionalCaptureTest18"));
 	    		cfgs.add(createLaunchConfiguration(jp, "EvalTestIntf18"));
 				cfgs.add(createLaunchConfiguration(jp, "EvalIntfSuperDefault"));
 				cfgs.add(createLaunchConfiguration(jp, "DebugHoverTest18"));
@@ -2845,10 +2848,10 @@
 			}
 			IEvaluationResult result = listener.getResult();
 			assertNotNull("The evaluation should have result: ", result);
-			assertNull("The evaluation should not have exception : " + result.getException(), result.getException());
+			assertNull("Evaluation of '" + snippet + "' should not have exception : " + findCause(result.getException()), result.getException());
 
 			String firstError = result.hasErrors() ? result.getErrorMessages()[0] : "";
-			assertFalse("The evaluation should not have errors : " + firstError, result.hasErrors());
+			assertFalse("The evaluation of '\" + snippet + \"'  should not have errors : " + firstError, result.hasErrors());
 			return listener.getResult().getValue();
 		}
 		finally {
@@ -2856,6 +2859,17 @@
 		}
 	}
 
+	private static Object findCause(DebugException problem) {
+		if (problem == null) {
+			return null;
+		}
+		Throwable cause = problem.getCause();
+		if (cause instanceof InvocationException) {
+			return ((InvocationException)cause).exception().toString();
+		}
+		return cause;
+	}
+
 	/**
 	 * @return true if the UI event loop should be proicessed during wait operations on UI thread
 	 */
diff --git a/org.eclipse.jdt.debug.tests/tests/org/eclipse/jdt/debug/tests/AutomatedSuite.java b/org.eclipse.jdt.debug.tests/tests/org/eclipse/jdt/debug/tests/AutomatedSuite.java
index 8ed5ac9..8b73956 100644
--- a/org.eclipse.jdt.debug.tests/tests/org/eclipse/jdt/debug/tests/AutomatedSuite.java
+++ b/org.eclipse.jdt.debug.tests/tests/org/eclipse/jdt/debug/tests/AutomatedSuite.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2019 IBM Corporation and others.
+ * Copyright (c) 2000, 2020 IBM Corporation and others.
  *
  * This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
@@ -39,6 +39,7 @@
 import org.eclipse.jdt.debug.tests.breakpoints.PatternBreakpointTests;
 import org.eclipse.jdt.debug.tests.breakpoints.PreLaunchBreakpointTest;
 import org.eclipse.jdt.debug.tests.breakpoints.RunToLineTests;
+import org.eclipse.jdt.debug.tests.breakpoints.SpecialExceptionBreakpointTests;
 import org.eclipse.jdt.debug.tests.breakpoints.SuspendVMBreakpointsTests;
 import org.eclipse.jdt.debug.tests.breakpoints.TargetPatternBreakpointTests;
 import org.eclipse.jdt.debug.tests.breakpoints.TestToggleBreakpointsTarget;
@@ -343,6 +344,7 @@
 		addTest(new TestSuite(BreakpointWorkingSetTests.class));
 		addTest(new TestSuite(MethodBreakpointTests.class));
 		addTest(new TestSuite(ExceptionBreakpointTests.class));
+		addTest(new TestSuite(SpecialExceptionBreakpointTests.class));
 		addTest(new TestSuite(WatchpointTests.class));
 		addTest(new TestSuite(PatternBreakpointTests.class));
 		addTest(new TestSuite(TargetPatternBreakpointTests.class));
diff --git a/org.eclipse.jdt.debug.tests/tests/org/eclipse/jdt/debug/tests/breakpoints/SpecialExceptionBreakpointTests.java b/org.eclipse.jdt.debug.tests/tests/org/eclipse/jdt/debug/tests/breakpoints/SpecialExceptionBreakpointTests.java
new file mode 100644
index 0000000..dfdcc5a
--- /dev/null
+++ b/org.eclipse.jdt.debug.tests/tests/org/eclipse/jdt/debug/tests/breakpoints/SpecialExceptionBreakpointTests.java
@@ -0,0 +1,179 @@
+/*******************************************************************************
+ * Copyright (c) 2020 GK Software SE and others.
+ *
+ * This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *     Stephan Herrmann - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jdt.debug.tests.breakpoints;
+
+import org.eclipse.core.resources.IMarker;
+import org.eclipse.core.runtime.preferences.IEclipsePreferences;
+import org.eclipse.core.runtime.preferences.InstanceScope;
+import org.eclipse.debug.core.DebugException;
+import org.eclipse.debug.core.model.IBreakpoint;
+import org.eclipse.jdt.debug.core.IJavaExceptionBreakpoint;
+import org.eclipse.jdt.debug.core.IJavaExceptionBreakpoint.SuspendOnRecurrenceStrategy;
+import org.eclipse.jdt.debug.core.IJavaStackFrame;
+import org.eclipse.jdt.debug.core.IJavaThread;
+import org.eclipse.jdt.debug.core.JDIDebugModel;
+import org.eclipse.jdt.debug.tests.AbstractDebugTest;
+import org.eclipse.jdt.internal.debug.core.JDIDebugPlugin;
+import org.eclipse.jdt.internal.debug.ui.IJDIPreferencesConstants;
+import org.eclipse.jdt.internal.debug.ui.JDIDebugUIPlugin;
+import org.eclipse.jdt.internal.debug.ui.JavaDebugOptionsManager;
+import org.eclipse.jface.preference.IPreferenceStore;
+
+public class SpecialExceptionBreakpointTests extends AbstractDebugTest {
+
+	private boolean fDefaultSuspendOnUncaught;
+	private boolean fDefaultSuspendOnCompilationErrors;
+	private SuspendOnRecurrenceStrategy fDefaultRecurrenceStrategy;
+
+	public SpecialExceptionBreakpointTests(String name) {
+		super(name);
+	}
+
+	@Override
+	protected void setUp() throws Exception {
+		super.setUp();
+		IPreferenceStore uiPrefStore = JDIDebugUIPlugin.getDefault().getPreferenceStore();
+		fDefaultSuspendOnUncaught = uiPrefStore.getBoolean(IJDIPreferencesConstants.PREF_SUSPEND_ON_UNCAUGHT_EXCEPTIONS);
+		fDefaultSuspendOnCompilationErrors = uiPrefStore.getBoolean(IJDIPreferencesConstants.PREF_SUSPEND_ON_COMPILATION_ERRORS);
+		IEclipsePreferences prefs = InstanceScope.INSTANCE.getNode(JDIDebugPlugin.getUniqueIdentifier());
+		String val = prefs.get(JDIDebugModel.PREF_SUSPEND_ON_RECURRENCE_STRATEGY, SuspendOnRecurrenceStrategy.RECURRENCE_UNCONFIGURED.name());
+		fDefaultRecurrenceStrategy = SuspendOnRecurrenceStrategy.valueOf(val);
+	}
+
+	@Override
+	protected void tearDown() throws Exception {
+		super.tearDown();
+		setPreferences(fDefaultSuspendOnUncaught, fDefaultSuspendOnCompilationErrors, fDefaultRecurrenceStrategy);
+	}
+
+	void setPreferences(boolean suspUncaught, boolean suspCompErr, SuspendOnRecurrenceStrategy recurr) {
+		IPreferenceStore uiPrefStore = JDIDebugUIPlugin.getDefault().getPreferenceStore();
+		uiPrefStore.setValue(IJDIPreferencesConstants.PREF_SUSPEND_ON_UNCAUGHT_EXCEPTIONS, suspUncaught);
+		uiPrefStore.setValue(IJDIPreferencesConstants.PREF_SUSPEND_ON_COMPILATION_ERRORS, suspCompErr);
+		IEclipsePreferences prefs = InstanceScope.INSTANCE.getNode(JDIDebugPlugin.getUniqueIdentifier());
+		prefs.put(JDIDebugModel.PREF_SUSPEND_ON_RECURRENCE_STRATEGY, recurr.name());
+	}
+
+	public void testCaughtException_compErr() throws Exception {
+		caughtException(true);
+	}
+	public void testCaughtException() throws Exception {
+		caughtException(false);
+	}
+	void caughtException(boolean suspendOnCompErr) throws Exception {
+		setPreferences(true, suspendOnCompErr, SuspendOnRecurrenceStrategy.SUSPEND_ALWAYS);
+
+		String typeName = "ErrorRecurrence";
+		IJavaExceptionBreakpoint ex = createExceptionBreakpoint("java.lang.Error", true, true);
+
+		IJavaThread thread = null;
+		try {
+			thread = launchToBreakpoint(typeName);
+			assertNotNull("1. Breakpoint not hit within timeout period", thread);
+			assertEquals("Line of 1. suspend", 26, thread.getTopStackFrame().getLineNumber());
+			assertExceptionBreakpointHit(thread, ex);
+
+			thread = resume(thread);
+			assertExceptionBreakpointHit(thread, ex);
+			assertNotNull("2. Breakpoint not hit within timeout period", thread);
+			assertEquals("Line of 2. suspend", 20, thread.getTopStackFrame().getLineNumber());
+
+			thread = resume(thread);
+			assertExceptionBreakpointHit(thread, ex);
+			assertNotNull("3. Breakpoint not hit within timeout period", thread);
+			assertEquals("Line of 3. suspend", 12, thread.getTopStackFrame().getLineNumber());
+
+			resumeAndExit(thread);
+			ex.delete();
+		} finally {
+			terminateAndRemove(thread);
+			removeAllBreakpoints();
+		}
+	}
+
+	public void testCaughtExceptionSkip_uncaught_compErr() throws Exception {
+		caughtExceptionSkip_uncaught(true);
+	}
+	public void testCaughtExceptionSkip_uncaught() throws Exception {
+		caughtExceptionSkip_uncaught(false);
+	}
+	void caughtExceptionSkip_uncaught(boolean suspendOnCompErr) throws Exception {
+		setPreferences(true, suspendOnCompErr, SuspendOnRecurrenceStrategy.SKIP_RECURRENCES);
+
+		String typeName = "ErrorRecurrence";
+		IJavaExceptionBreakpoint ex = createExceptionBreakpoint("java.lang.Error", true, true);
+
+		IJavaThread thread = null;
+		try {
+			thread = launchToBreakpoint(typeName);
+			assertNotNull("1. Breakpoint not hit within timeout period", thread);
+			assertEquals("Line of 1. suspend", 26, thread.getTopStackFrame().getLineNumber());
+			assertExceptionBreakpointHit(thread, ex);
+
+			// L20 skipped recurrence
+
+			// L12: uncaught:
+			thread = resume(thread);
+			assertExceptionBreakpointHit(thread, ex);
+			assertNotNull("2. Breakpoint not hit within timeout period", thread);
+			assertEquals("Line of 2. suspend", 12, thread.getTopStackFrame().getLineNumber());
+
+			resumeAndExit(thread);
+			ex.delete();
+		} finally {
+			terminateAndRemove(thread);
+			removeAllBreakpoints();
+		}
+	}
+
+	public void testCaughtExceptionSkip_compErr() throws Exception {
+		caughtExceptionSkip(true);
+	}
+	public void testCaughtExceptionSkip() throws Exception {
+		caughtExceptionSkip(false);
+	}
+	void caughtExceptionSkip(boolean suspendOnCompErr) throws Exception {
+		setPreferences(false, suspendOnCompErr, SuspendOnRecurrenceStrategy.SKIP_RECURRENCES);
+
+		String typeName = "ErrorRecurrence";
+		IJavaExceptionBreakpoint ex = createExceptionBreakpoint("java.lang.Error", true, true);
+
+		IJavaThread thread = null;
+		try {
+			thread = launchToBreakpoint(typeName);
+			assertNotNull("1. Breakpoint not hit within timeout period", thread);
+			assertEquals("Line of 1. suspend", 26, thread.getTopStackFrame().getLineNumber());
+			assertExceptionBreakpointHit(thread, ex);
+
+			// L20 skipped recurrence
+
+			// L12 suspend on uncaught disabled
+			resumeAndExit(thread);
+			ex.delete();
+		} finally {
+			terminateAndRemove(thread);
+			removeAllBreakpoints();
+		}
+	}
+
+	private void assertExceptionBreakpointHit(IJavaThread thread, IJavaExceptionBreakpoint ex) throws DebugException {
+		IMarker problem = JavaDebugOptionsManager.getDefault().getProblem((IJavaStackFrame) thread.getTopStackFrame());
+		if (problem != null) {
+			fail("unexpected problem marker "+problem);
+		}
+		IBreakpoint hit = getBreakpoint(thread);
+		assertNotNull("suspended, but not by breakpoint", hit);
+		assertEquals("suspended, but not by expected exception", ex.getExceptionTypeName(), ((IJavaExceptionBreakpoint) hit).getExceptionTypeName());
+	}
+}
diff --git a/org.eclipse.jdt.debug.tests/tests/org/eclipse/jdt/debug/tests/eval/Java8Tests.java b/org.eclipse.jdt.debug.tests/tests/org/eclipse/jdt/debug/tests/eval/Java8Tests.java
index 9c14ddd..9353f40 100644
--- a/org.eclipse.jdt.debug.tests/tests/org/eclipse/jdt/debug/tests/eval/Java8Tests.java
+++ b/org.eclipse.jdt.debug.tests/tests/org/eclipse/jdt/debug/tests/eval/Java8Tests.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2014, 2015 Jesper S. Møller and others.
+ * Copyright (c) 2014, 2020 Jesper S. Møller and others.
  *
  * This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
@@ -17,6 +17,7 @@
 package org.eclipse.jdt.debug.tests.eval;
 
 import org.eclipse.debug.core.model.IValue;
+import org.eclipse.jdt.core.ICompilationUnit;
 import org.eclipse.jdt.core.IJavaProject;
 import org.eclipse.jdt.debug.core.IJavaLineBreakpoint;
 import org.eclipse.jdt.debug.core.IJavaThread;
@@ -129,4 +130,115 @@
 			terminateAndRemove(thread);
 		}
 	}
+
+	/**
+	 * Evaluates a snippet containing a lambda
+	 *
+	 * @throws Exception
+	 */
+	public void testEvalLambda() throws Exception {
+		IJavaThread thread = null;
+		try {
+			String type = "EvalTest18";
+			IJavaLineBreakpoint bp = createLineBreakpoint(28, type);
+			assertNotNull("should have created breakpoint", bp);
+			thread = launchToBreakpoint(type);
+			assertNotNull("The program did not suspend", thread);
+			String snippet = "l.stream().filter(i -> i > 2).count()";
+			IValue result = doEval(thread, snippet);
+			assertEquals("2", result.getValueString());
+		} finally {
+			removeAllBreakpoints();
+			terminateAndRemove(thread);
+		}
+	}
+
+	/**
+	 * Evaluates a snippet containing a lambda referencing a variable in a loop
+	 *
+	 * @throws Exception
+	 */
+	public void testEvalLambdaInLoop() throws Exception {
+		IJavaThread thread = null;
+		try {
+			String type = "EvalTest18";
+			IJavaLineBreakpoint bp = createLineBreakpoint(31, type);
+			assertNotNull("should have created breakpoint", bp);
+			thread = launchToBreakpoint(type);
+			assertNotNull("The program did not suspend", thread);
+			String snippet = "l.stream().filter(j -> j > i+1).count()";
+			IValue result = doEval(thread, snippet);
+			assertEquals("2", result.getValueString());
+		} finally {
+			removeAllBreakpoints();
+			terminateAndRemove(thread);
+		}
+	}
+
+	/**
+	 * Evaluates a snippet containing a method reference
+	 *
+	 * @throws Exception
+	 */
+	public void testEvalMethodReference() throws Exception {
+		IJavaThread thread = null;
+		try {
+			String type = "EvalTest18";
+			IJavaLineBreakpoint bp = createLineBreakpoint(28, type);
+			assertNotNull("should have created breakpoint", bp);
+			thread = launchToBreakpoint(type);
+			assertNotNull("The program did not suspend", thread);
+			String snippet = "l.stream().mapToInt(Integer::bitCount).sum()";
+			IValue result = doEval(thread, snippet);
+			assertEquals("5", result.getValueString());
+		} finally {
+			removeAllBreakpoints();
+			terminateAndRemove(thread);
+		}
+	}
+
+	/**
+	 * Evaluates a snippet containing a method reference
+	 *
+	 * @throws Exception
+	 */
+	public void testContextEvaluations() throws Exception {
+		IJavaThread thread = null;
+		try {
+			String type = "FunctionalCaptureTest18";
+			ICompilationUnit cu = getType(type).getCompilationUnit();
+			String[] lines = new String(cu.getBuffer().getCharacters()).split("\n");
+
+			int i = 0;
+			for (; i < lines.length; ++i) {
+				if (lines[i].contains("/* CHECK EXPRESSIONS BELOW */")) break;
+			}
+			assertTrue("Missing source marker", i < lines.length);
+			IJavaLineBreakpoint bp = createLineBreakpoint(i, type);
+			assertNotNull("should have created breakpoint", bp);
+			thread = launchToBreakpoint(type);
+			assertNotNull("The program did not suspend", thread);
+			
+			for (; i < lines.length; ++i) {
+				String line = lines[i];
+				
+				if (line.contains("/* END OF TESTS */")) break; 
+				if (line.trim().startsWith("/") || line.trim().isEmpty()) continue; // Comment, just skip it
+				if (line.contains("/* SKIP */")) continue;
+				
+				int lastSemicolon = line.lastIndexOf(';');
+				assertTrue(lastSemicolon > 1);
+				String snippet = line.substring(0,  lastSemicolon).trim();
+				//System.out.println("*******************: " + snippet);
+				IValue result = doEval(thread, snippet);
+				assertNotNull(result);
+				//System.out.println(">>>>>>>>>>>>>>>>>>>: " + result.getReferenceTypeName());
+			}
+			
+		} finally {
+			removeAllBreakpoints();
+			terminateAndRemove(thread);
+		}
+	}
+
 }
diff --git a/org.eclipse.jdt.debug.ui/plugin.xml b/org.eclipse.jdt.debug.ui/plugin.xml
index 0a44a67..287975f 100644
--- a/org.eclipse.jdt.debug.ui/plugin.xml
+++ b/org.eclipse.jdt.debug.ui/plugin.xml
@@ -3406,6 +3406,7 @@
             class="org.eclipse.jdt.internal.debug.ui.console.JavaConsoleTracker"
             regex="\(\w*${java_extensions_regex}\S*\)"
             qualifier="${java_extensions_regex}"
+            flags="UNICODE_CHARACTER_CLASS"
             id="org.eclipse.jdt.debug.ui.JavaConsoleTracker">
          <enablement>
             <or>
@@ -3432,6 +3433,7 @@
             class="org.eclipse.jdt.internal.debug.ui.console.JavaExceptionConsoleTracker"
             regex="\w[^\(\s]+Exception[\s|:]"
             qualifier="Exception[\s|:]"
+            flags="UNICODE_CHARACTER_CLASS"
             id="org.eclipse.jdt.debug.ui.JavaExceptionConsoleTracker">
          <enablement>
             <or>
diff --git a/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/JavaDebugOptionsManager.java b/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/JavaDebugOptionsManager.java
index 63c1ff9..d1fe3b7 100644
--- a/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/JavaDebugOptionsManager.java
+++ b/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/JavaDebugOptionsManager.java
@@ -583,6 +583,15 @@
 	@Override
 	public int breakpointHit(IJavaThread thread, IJavaBreakpoint breakpoint) {
 		if (thread instanceof JDIThread && breakpoint instanceof IJavaExceptionBreakpoint) {
+			try {
+				String[] breakpointListeners = breakpoint.getBreakpointListeners();
+				if (breakpointListeners.length == 1
+						&& SuspendOnCompilationErrorListener.ID_COMPILATION_ERROR_LISTENER.equals(breakpointListeners[0])) {
+					return DONT_CARE; // not a user breakpoint
+				}
+			} catch (CoreException e1) {
+				// continue
+			}
 			if (shouldSkipSubsequentOccurrence((JDIThread) thread, (IJavaExceptionBreakpoint) breakpoint)) {
 				return DONT_SUSPEND;
 			}
diff --git a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/EvaluationMessages.java b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/EvaluationMessages.java
index f077d87..bee3ae2 100644
--- a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/EvaluationMessages.java
+++ b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/EvaluationMessages.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2007 IBM Corporation and others.
+ * Copyright (c) 2000, 2020 IBM Corporation and others.
  *
  * This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
@@ -28,7 +28,8 @@
 	public static String LocalEvaluationEngine_Evaluation_failed___unable_to_initialize_local_variables__6;
 	public static String LocalEvaluationEngine_Evaluation_failed___unable_to_initialize___this___context__5;
 	public static String LocalEvaluationEngine_Evaluation_failed___unable_to_initialize_local_variables__4;
-
+	public static String RemoteEvaluationEngine_Evaluation_failed___unable_to_instantiate_snippet_class;
+	public static String RemoteEvaluationEngine_Evaluation_failed___unable_to_find_injected_class;
 	static {
 		// load message values from bundle file
 		NLS.initializeMessages(BUNDLE_NAME, EvaluationMessages.class);
diff --git a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/EvaluationMessages.properties b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/EvaluationMessages.properties
index e11fa21..b970e07 100644
--- a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/EvaluationMessages.properties
+++ b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/EvaluationMessages.properties
@@ -1,5 +1,5 @@
 ###############################################################################
-# Copyright (c) 2000, 2007 IBM Corporation and others.
+# Copyright (c) 2000, 2020 IBM Corporation and others.
 #
 # This program and the accompanying materials
 # are made available under the terms of the Eclipse Public License 2.0
@@ -22,3 +22,5 @@
 LocalEvaluationEngine_Evaluation_failed___unable_to_initialize_local_variables__6=Evaluation failed - unable to initialize local variables.
 LocalEvaluationEngine_Evaluation_failed___unable_to_initialize___this___context__5=Evaluation failed - unable to initialize \'this\' context.
 LocalEvaluationEngine_Evaluation_failed___unable_to_initialize_local_variables__4=Evaluation failed - unable to initialize local variables.
+RemoteEvaluationEngine_Evaluation_failed___unable_to_instantiate_snippet_class=Evaluation failed - generated class could not be instantiated.
+RemoteEvaluationEngine_Evaluation_failed___unable_to_find_injected_class=Evaluation failed - unable to find injected class
diff --git a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/EvaluationResult.java b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/EvaluationResult.java
index 87dd2fa..581b138 100644
--- a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/EvaluationResult.java
+++ b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/EvaluationResult.java
@@ -14,7 +14,6 @@
 package org.eclipse.jdt.internal.debug.eval;
 
 import java.util.ArrayList;
-import java.util.Iterator;
 import java.util.List;
 
 import org.eclipse.debug.core.DebugException;
@@ -113,8 +112,8 @@
 	public Message[] getErrors() {
 		Message[] messages = new Message[fErrors.size()];
 		int i = 0;
-		for (Iterator<String> iter = fErrors.iterator(); iter.hasNext();) {
-			messages[i++] = new Message(iter.next(), -1);
+		for (String errMsg : fErrors) {
+			messages[i++] = new Message(errMsg, -1);
 		}
 		return messages;
 	}
diff --git a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ExpressionBinder.java b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ExpressionBinder.java
new file mode 100644
index 0000000..2fa84cf
--- /dev/null
+++ b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ExpressionBinder.java
@@ -0,0 +1,10 @@
+package org.eclipse.jdt.internal.debug.eval;
+
+import org.eclipse.jdt.core.dom.ITypeBinding;
+import org.eclipse.jdt.core.dom.IVariableBinding;
+
+public interface ExpressionBinder {
+	// Record and register the binding specified
+	void bind(IVariableBinding variableToBind, String asVariableName);
+	void bindThis(ITypeBinding thisForType, String asVariableName);
+}
diff --git a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/RemoteEvaluator.java b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/RemoteEvaluator.java
new file mode 100644
index 0000000..c19fab8
--- /dev/null
+++ b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/RemoteEvaluator.java
@@ -0,0 +1,364 @@
+/*******************************************************************************
+
+ * Copyright (c) 2019, 2020 Jesper Steen Møller and others.
+ *
+ * This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *     Jesper Steen Møller - initial API and implementation
+ *     IBM Corporation - Bug 448473 - [1.8][debug] Cannot use lambda expressions in breakpoint properties and display/expression view
+ *******************************************************************************/
+package org.eclipse.jdt.internal.debug.eval;
+
+import static org.eclipse.jdt.core.eval.ICodeSnippetRequestor.LOCAL_VAR_PREFIX;
+
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.debug.core.DebugException;
+import org.eclipse.debug.core.model.IVariable;
+import org.eclipse.jdt.core.eval.ICodeSnippetRequestor;
+import org.eclipse.jdt.debug.core.IJavaArray;
+import org.eclipse.jdt.debug.core.IJavaArrayType;
+import org.eclipse.jdt.debug.core.IJavaClassObject;
+import org.eclipse.jdt.debug.core.IJavaClassType;
+import org.eclipse.jdt.debug.core.IJavaDebugTarget;
+import org.eclipse.jdt.debug.core.IJavaObject;
+import org.eclipse.jdt.debug.core.IJavaReferenceType;
+import org.eclipse.jdt.debug.core.IJavaThread;
+import org.eclipse.jdt.debug.core.IJavaType;
+import org.eclipse.jdt.debug.core.IJavaValue;
+import org.eclipse.jdt.debug.core.IJavaVariable;
+import org.eclipse.jdt.debug.core.JDIDebugModel;
+import org.eclipse.jdt.internal.debug.core.JDIDebugPlugin;
+import org.eclipse.jdt.internal.debug.core.model.JDIDebugTarget;
+import org.eclipse.jdt.internal.debug.core.model.JDIValue;
+
+import com.sun.jdi.InvocationException;
+import com.sun.jdi.ObjectReference;
+
+/**
+ * An evaluation engine that deploys class files to a debuggee by using Unsafe through the JDWP.
+ */
+
+public class RemoteEvaluator {
+
+	private final LinkedHashMap<String, byte[]> classFiles;
+
+	private final String codeSnippetClassName;
+
+	private final List<String> variableNames;
+
+	private IJavaClassObject loadedClass = null;
+
+	private String enclosingTypeName;
+
+	/**
+	 * Constructs a new evaluation engine for the given VM in the context of the specified project. Class files required for the evaluation will be
+	 * deployed to the specified directory (which must be on the class path of the VM in order for evaluation to work).
+	 *
+	 * @param classFiles
+	 * @param codeSnippetClassName
+	 * @param variableNames
+	 * @param enclosingTypeName
+	 */
+	public RemoteEvaluator(LinkedHashMap<String, byte[]> classFiles, String codeSnippetClassName, List<String> variableNames, String enclosingTypeName) {
+		this.classFiles = classFiles;
+		this.enclosingTypeName = enclosingTypeName;
+		this.codeSnippetClassName = codeSnippetClassName.replace('.', '/');
+		this.variableNames = variableNames;
+	}
+
+	private IJavaClassObject loadTheClasses(IJavaThread theThread) throws DebugException {
+
+		if (loadedClass != null) {
+			return loadedClass;
+		}
+		JDIDebugTarget debugTarget = ((JDIDebugTarget) theThread.getDebugTarget());
+		IJavaClassObject theMainClass = null;
+		IJavaObject classloader = null;
+
+		IJavaReferenceType surroundingClass = findType(this.enclosingTypeName, debugTarget);
+		classloader = surroundingClass.getClassLoaderObject();
+
+		for (Map.Entry<String, byte[]> entry : classFiles.entrySet()) {
+			String className = entry.getKey();
+
+			IJavaReferenceType existingClass = tryLoadType(className, debugTarget);
+			if (existingClass != null) {
+				if (codeSnippetClassName.equals(className)) {
+					theMainClass = existingClass.getClassObject();
+				}
+			} else {
+				IJavaArray byteArray = createClassBytes(theThread, debugTarget, entry);
+				IJavaValue[] defineClassArgs = new IJavaValue[] { // args for defineClass
+						debugTarget.newValue(className.replaceAll("/", ".")), // class name //$NON-NLS-1$ //$NON-NLS-2$
+						byteArray, // classBytes,
+						debugTarget.newValue(0), // offset
+						debugTarget.newValue(entry.getValue().length), // length
+						debugTarget.nullValue() // protection domain
+				};
+
+				IJavaClassObject theClass = (IJavaClassObject) classloader.sendMessage("defineClass", "(Ljava/lang/String;[BIILjava/security/ProtectionDomain;)Ljava/lang/Class;", defineClassArgs, theThread, false); //$NON-NLS-1$//$NON-NLS-2$
+				if (codeSnippetClassName.equals(className)) {
+					theMainClass = theClass;
+				}
+			}
+		}
+		return theMainClass;
+	}
+
+	private IJavaArray createClassBytes(IJavaThread theThread, JDIDebugTarget debugTarget, Map.Entry<String, byte[]> entry) throws DebugException {
+		IJavaReferenceType byteArrayType = findType("byte[]", debugTarget);//$NON-NLS-1$
+		byte[] classBytes = entry.getValue();
+		IJavaArray byteArray = ((IJavaArrayType) byteArrayType).newInstance(classBytes.length);
+
+		IJavaValue[] debugClassBytes = new IJavaValue[classBytes.length];
+		for (int ix = 0; ix < classBytes.length; ++ix) {
+			debugClassBytes[ix] = ((JDIDebugTarget) theThread.getDebugTarget()).newValue(classBytes[ix]);
+		}
+		byteArray.setValues(debugClassBytes);
+		return byteArray;
+	}
+
+	private IJavaReferenceType findType(String typeName, IJavaDebugTarget debugTarget) throws DebugException {
+		IJavaReferenceType theClass = tryLoadType(typeName, debugTarget);
+		if (theClass == null) {
+			// unable to load the class
+			throw new DebugException(
+					new Status(
+							IStatus.ERROR,
+							JDIDebugModel.getPluginIdentifier(),
+							DebugException.REQUEST_FAILED,
+							EvaluationMessages.RemoteEvaluationEngine_Evaluation_failed___unable_to_find_injected_class,
+							null));
+		}
+		return theClass;
+	}
+
+	private IJavaReferenceType tryLoadType(String typeName, IJavaDebugTarget debugTarget) throws DebugException {
+		IJavaReferenceType clazz = null;
+		IJavaType[] types = debugTarget.getJavaTypes(typeName);
+		if (types != null && types.length > 0) {
+			clazz = (IJavaReferenceType) types[0];
+		}
+		return clazz;
+	}
+
+	/**
+	 * Initializes the value of instance variables in the 'code snippet object' that are used as place-holders for free variables and 'this' in the
+	 * current stack frame.
+	 *
+	 * @param object
+	 *            instance of code snippet class that will be run
+	 * @param boundValues
+	 *            popped values which should be injected into the code snippet object.
+	 * @exception DebugException
+	 *                if an exception is thrown accessing the given object
+	 */
+	protected void initializeFreeVars(IJavaObject object, IJavaValue boundValues[]) throws DebugException {
+		if (boundValues.length != this.variableNames.size()) {
+			throw new DebugException(new Status(IStatus.ERROR, JDIDebugModel.getPluginIdentifier(), DebugException.REQUEST_FAILED, EvaluationMessages.LocalEvaluationEngine_Evaluation_failed___unable_to_initialize_local_variables__4, null));
+		}
+
+		for (int i = 0; i < boundValues.length; ++i) {
+			IJavaVariable field = object.getField(new String(LOCAL_VAR_PREFIX) + this.variableNames.get(i), false);
+			if (field != null) {
+				IJavaValue bound = boundValues[i];
+				field.setValue(bound);
+			} else {
+				// System.out.print(Arrays.asList(((IJavaReferenceType) object.getJavaType()).getAllFieldNames()));
+				throw new DebugException(new Status(IStatus.ERROR, JDIDebugModel.getPluginIdentifier(), DebugException.REQUEST_FAILED, EvaluationMessages.LocalEvaluationEngine_Evaluation_failed___unable_to_initialize_local_variables__4, null));
+			}
+		}
+	}
+
+	/**
+	 * Constructs and returns a new instance of the specified class on the
+	 * target VM.
+	 *
+	 * @param className
+	 *            fully qualified class name
+	 * @return a new instance on the target, as an <code>IJavaValue</code>
+	 * @exception DebugException
+	 *                if creation fails
+	 */
+	protected IJavaObject newInstance(IJavaThread theThread) throws DebugException {
+		IJavaDebugTarget debugTarget = ((IJavaDebugTarget) theThread.getDebugTarget());
+
+		IJavaObject object = null;
+		IJavaClassObject clazz = loadTheClasses(theThread);
+		if (clazz == null) {
+			// The class is not loaded on the target VM.
+			// Force the load of the class.
+			IJavaType[] types = debugTarget.getJavaTypes("java.lang.Class"); //$NON-NLS-1$
+			IJavaClassType classClass = null;
+			if (types != null && types.length > 0) {
+				classClass = (IJavaClassType) types[0];
+			}
+			if (classClass == null) {
+				// unable to load the class
+				throw new DebugException(
+						new Status(
+								IStatus.ERROR,
+								JDIDebugModel.getPluginIdentifier(),
+								DebugException.REQUEST_FAILED,
+								EvaluationMessages.LocalEvaluationEngine_Evaluation_failed___unable_to_instantiate_code_snippet_class__11,
+								null));
+			}
+			IJavaValue[] args = new IJavaValue[] { debugTarget.newValue(
+					this.codeSnippetClassName) };
+			IJavaObject classObject = (IJavaObject) classClass
+					.sendMessage(
+							"forName", "(Ljava/lang/String;)Ljava/lang/Class;", args, theThread); //$NON-NLS-2$ //$NON-NLS-1$
+			object = (IJavaObject) classObject
+					.sendMessage(
+							"newInstance", "()Ljava/lang/Object;", null, theThread, false); //$NON-NLS-2$ //$NON-NLS-1$
+		} else {
+			object = (IJavaObject) clazz.sendMessage("newInstance", "()Ljava/lang/Object;", null, theThread, false); //$NON-NLS-2$ //$NON-NLS-1$
+			// object = clazz.newInstance("<init>", null, theThread); //$NON-NLS-1$
+		}
+		return object;
+	}
+
+	/**
+	 * Interprets and returns the result of the running the snippet class file.
+	 * The type of the result is described by an instance of
+	 * <code>java.lang.Class</code>. The value is interpreted based on the
+	 * result type.
+	 * <p>
+	 * Objects as well as primitive data types (boolean, int, etc.), have class
+	 * objects, which are created by the VM. If the class object represents a
+	 * primitive data type, then the associated value is stored in an instance
+	 * of its "object" class. For example, when the result type is the class
+	 * object for <code>int</code>, the result object is an instance of
+	 * <code>java.lang.Integer</code>, and the actual <code>int</code> is stored
+	 * in the </code>intValue()</code>. When the result type is the class object
+	 * for <code>java.lang.Integer</code> the result object is an instance of
+	 * <code>java.lang.Integer</code>, to be interpreted as a
+	 * <code>java.lang.Integer</code>.
+	 * </p>
+	 *
+	 * @param resultType
+	 *            the class of the result
+	 * @param resultValue
+	 *            the value of the result, to be interpreted based on
+	 *            resultType
+	 * @return the result of running the code snippet class file
+	 */
+	protected IJavaValue convertResult(IJavaDebugTarget debugTarget, IJavaClassObject resultType,
+			IJavaValue result) throws DebugException {
+		if (resultType == null) {
+			// there was an exception or compilation problem - no result
+			return null;
+		}
+
+		// check the type of the result - if a primitive type, convert it
+		String sig = resultType.getInstanceType().getSignature();
+		if (sig.equals("V") || sig.equals("Lvoid;")) { //$NON-NLS-2$ //$NON-NLS-1$
+			// void
+			return debugTarget.voidValue();
+		}
+
+		if (result.getJavaType() == null) {
+			// null result
+			return result;
+		}
+
+		if (sig.length() == 1) {
+			// primitive type - find the instance variable with the
+			// signature of the result type we are looking for
+			IVariable[] vars = result.getVariables();
+			IJavaVariable var = null;
+			for (IVariable var2 : vars) {
+				IJavaVariable jv = (IJavaVariable) var2;
+				if (!jv.isStatic() && jv.getSignature().equals(sig)) {
+					var = jv;
+					break;
+				}
+			}
+			if (var != null) {
+				return (IJavaValue) var.getValue();
+			}
+		} else {
+			// an object
+			return result;
+		}
+		throw new DebugException(
+				new Status(
+						IStatus.ERROR,
+						JDIDebugModel.getPluginIdentifier(),
+						DebugException.REQUEST_FAILED,
+						EvaluationMessages.LocalEvaluationEngine_Evaluation_failed___internal_error_retreiving_result__17,
+						null));
+	}
+
+	/**
+	 * Returns the name of the code snippet to instantiate to run the current
+	 * evaluation.
+	 *
+	 * @return the name of the deployed code snippet to instantiate and run
+	 */
+	protected String getCodeSnippetClassName() {
+		return codeSnippetClassName;
+	}
+
+	public IJavaValue evaluate(IJavaThread theThread, IJavaValue[] args) throws DebugException {
+		IJavaObject codeSnippetInstance = null;
+		IJavaDebugTarget debugTarget = ((IJavaDebugTarget) theThread.getDebugTarget());
+		try {
+			codeSnippetInstance = newInstance(theThread);
+			initializeFreeVars(codeSnippetInstance, args);
+			codeSnippetInstance.sendMessage(ICodeSnippetRequestor.RUN_METHOD, "()V", null, theThread, false); //$NON-NLS-1$
+
+			// now retrieve the description of the result
+			IVariable[] fields = codeSnippetInstance.getVariables();
+			IJavaVariable resultValue = null;
+			IJavaVariable resultType = null;
+			for (IVariable field : fields) {
+				if (field.getName().equals(ICodeSnippetRequestor.RESULT_TYPE_FIELD)) {
+					resultType = (IJavaVariable) field;
+				}
+				if (field.getName().equals(ICodeSnippetRequestor.RESULT_VALUE_FIELD)) {
+					resultValue = (IJavaVariable) field;
+				}
+			}
+			IJavaValue result = convertResult(debugTarget, (IJavaClassObject) resultType.getValue(), (IJavaValue) resultValue.getValue());
+			return result;
+		} catch (DebugException e) {
+			Throwable underlyingException = e.getStatus().getException();
+			if (underlyingException instanceof InvocationException) {
+				ObjectReference theException = ((InvocationException) underlyingException).exception();
+				if (theException != null) {
+					try {
+						try {
+							IJavaObject v = (IJavaObject) JDIValue.createValue((JDIDebugTarget) debugTarget, theException);
+							v.sendMessage("printStackTrace", "()V", null, theThread, false); //$NON-NLS-2$ //$NON-NLS-1$
+						} catch (DebugException de) {
+							JDIDebugPlugin.log(de);
+						}
+					} catch (RuntimeException re) {
+						JDIDebugPlugin.log(re);
+					}
+				}
+			}
+			throw e;
+		}
+	}
+
+	public int getVariableCount() {
+		return this.variableNames.size();
+	}
+
+	public String getVariableName(int i) {
+		return this.variableNames.get(i);
+	}
+}
diff --git a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/RemoteEvaluatorBuilder.java b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/RemoteEvaluatorBuilder.java
new file mode 100644
index 0000000..03a05fa
--- /dev/null
+++ b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/RemoteEvaluatorBuilder.java
@@ -0,0 +1,2098 @@
+/*******************************************************************************
+ * Copyright (c) 2019 Jesper Steen Møller and others.
+ *
+ * This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *     Jesper Steen Møller - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jdt.internal.debug.eval;
+
+import static org.eclipse.jdt.core.eval.ICodeSnippetRequestor.LOCAL_VAR_PREFIX;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.eclipse.core.resources.IMarker;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.debug.core.DebugException;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.IType;
+import org.eclipse.jdt.core.JavaModelException;
+import org.eclipse.jdt.core.dom.*;
+import org.eclipse.jdt.core.eval.ICodeSnippetRequestor;
+import org.eclipse.jdt.core.eval.IEvaluationContext;
+import org.eclipse.jdt.internal.debug.core.JDIDebugPlugin;
+import org.eclipse.jdt.internal.debug.eval.ast.engine.EvaluationEngineMessages;
+
+/**
+ * A builder for a reuseable expression evaluator against a runnng VM.
+ */
+
+@SuppressWarnings("rawtypes")
+public class RemoteEvaluatorBuilder {
+
+	private IJavaProject javaProject;
+	private ExpressionBinder binder;
+	private final String enclosingTypeName;
+	private final String packageName;
+	private final boolean isStatic;
+	private final boolean isConstructor;
+	private final List<String> argumentNames = new ArrayList<>();
+	private final List<String> argumentTypeNames = new ArrayList<>();
+
+	/**
+	 * The names and bytecodes of the code snippet class to instantiate
+	 */
+	private LinkedHashMap<String, byte[]> classFiles = new LinkedHashMap<>();
+
+	/**
+	 * The name of the code snippet class to instantiate
+	 */
+	private String codeSnippetClassName = null;
+	private String snippet = null;
+	private final ITypeBinding enclosingClass;
+
+	public RemoteEvaluatorBuilder(IJavaProject javaProject, ExpressionBinder binder, ITypeBinding enclosingClass, boolean isStatic, boolean isConstructor) {
+		this.javaProject = javaProject;
+		this.binder = binder;
+		this.enclosingClass = enclosingClass;
+		this.enclosingTypeName = enclosingClass.getQualifiedName();
+		this.packageName = enclosingClass.getPackage().getName();
+		this.isStatic = isStatic;
+		this.isConstructor = isConstructor;
+	}
+
+	public void acceptLambda(LambdaExpression lambda, ITypeBinding expectedResult) {
+		acceptFunctionalExpression(lambda, expectedResult);
+	}
+
+	public void acceptMethodReference(MethodReference node, ITypeBinding expectedResult) {
+		acceptFunctionalExpression(node, expectedResult);
+	}
+
+	private void acceptFunctionalExpression(Expression node, ITypeBinding expectedResult) {
+		FunctionalEvalVisitor visitor = new FunctionalEvalVisitor();
+		node.accept(visitor);
+		String castExpression = "(" + expectedResult.getQualifiedName() + ")"; //$NON-NLS-1$//$NON-NLS-2$
+		this.snippet = castExpression + "(" + visitor.buffer.toString() + ")"; //$NON-NLS-1$//$NON-NLS-2$
+	}
+
+	public String getSnippet() {
+		return snippet;
+	}
+
+	private static Object EVALUATE_CODE_SNIPPET_LOCK = new Object();
+
+	public RemoteEvaluator build() throws JavaModelException, DebugException {
+
+		List<String> boundVariableNames = getVariableNames();
+		List<String> boundVariableTypeNames = getVariableTypeNames();
+
+		List<String> errors = new ArrayList<>();
+		IType enclosingType = this.javaProject.findType(enclosingTypeName);
+
+		if (enclosingType == null) {
+			throw new DebugException(new Status(IStatus.ERROR, JDIDebugPlugin.getUniqueIdentifier(), EvaluationEngineMessages.ASTInstructionCompiler_Functional_expressions_cannot_be_evaluated_inside_local_and_or_anonymous_classes));
+		}
+
+		synchronized (EVALUATE_CODE_SNIPPET_LOCK) {
+			IEvaluationContext context = this.javaProject.newEvaluationContext();
+			if (!packageName.startsWith("java.")) { //$NON-NLS-1$
+				context.setPackageName(this.packageName);
+			}
+			// System.out.println(this.snippet);
+			context.evaluateCodeSnippet(this.snippet, boundVariableTypeNames.toArray(new String[boundVariableNames.size()]), boundVariableNames.toArray(new String[boundVariableNames.size()]), new int[boundVariableNames.size()], enclosingType, isStatic, isConstructor, new ICodeSnippetRequestor() {
+
+				@Override
+				public void acceptProblem(IMarker problemMarker, String fragmentSource, int fragmentKind) {
+					if (problemMarker.getAttribute(IMarker.SEVERITY, IMarker.SEVERITY_INFO) >= IMarker.SEVERITY_ERROR) {
+						errors.add(problemMarker.toString());
+					}
+				}
+
+				@Override
+				public boolean acceptClassFiles(byte[][] classFileBytes, String[][] classFileCompoundNames, String mainCodeSnippetClassName) {
+					for (int i = 0; i < classFileCompoundNames.length; ++i) {
+						String className = makeClassName(classFileCompoundNames[i]);
+						classFiles.put(className, classFileBytes[i]);
+					}
+					if (mainCodeSnippetClassName != null) {
+						setCodeSnippetClassName(mainCodeSnippetClassName);
+					}
+					return true;
+				}
+			}, null);
+		}
+
+		if (!errors.isEmpty()) {
+			throw new DebugException(new Status(IStatus.ERROR, JDIDebugPlugin.getUniqueIdentifier(), errors.toString()));
+		}
+
+		return new RemoteEvaluator(classFiles, codeSnippetClassName, getVariableNames(), enclosingType.getFullyQualifiedName('$'));
+	}
+
+	private void setCodeSnippetClassName(String codeSnippetClassName) {
+		this.codeSnippetClassName = codeSnippetClassName;
+	}
+
+	private static String makeClassName(String[] names) {
+		StringBuilder sb = new StringBuilder();
+		for (int j = 0; j < names.length; j++) {
+			if (j > 0) {
+				sb.append('/');
+			}
+			sb.append(names[j]);
+		}
+		return sb.toString();
+	}
+
+	public List<String> getVariableTypeNames() {
+		return Collections.unmodifiableList(argumentTypeNames);
+	}
+
+	public List<String> getVariableNames() {
+		return Collections.unmodifiableList(argumentNames);
+	}
+
+	public String allocateNewVariable(ITypeBinding binding, String hint) {
+		String varName = hint + "$" + argumentNames.size(); //$NON-NLS-1$
+		argumentNames.add(varName);
+		argumentTypeNames.add(binding.getQualifiedName());
+		return varName;
+	}
+
+	public IJavaProject getJavaProject() {
+		return javaProject;
+	}
+
+	public String getEnclosingTypeName() {
+		return enclosingTypeName;
+	}
+
+	public boolean isStatic() {
+		return isStatic;
+	}
+
+	/**
+	 * Internal synonym for {@link MethodDeclaration#getReturnType()}. Use to alleviate deprecation warnings.
+	 *
+	 * @deprecated
+	 * @since 3.4
+	 */
+	@Deprecated
+	private static Type getReturnType(MethodDeclaration node) {
+		return node.getReturnType();
+	}
+
+	/**
+	 * Internal synonym for {@link TypeDeclaration#getSuperclass()}. Use to alleviate deprecation warnings.
+	 *
+	 * @deprecated
+	 * @since 3.4
+	 */
+	@Deprecated
+	private static Name getSuperclass(TypeDeclaration node) {
+		return node.getSuperclass();
+	}
+
+	/**
+	 * Internal synonym for {@link TypeDeclarationStatement#getTypeDeclaration()}. Use to alleviate deprecation warnings.
+	 *
+	 * @deprecated
+	 * @since 3.4
+	 */
+	@Deprecated
+	private static TypeDeclaration getTypeDeclaration(TypeDeclarationStatement node) {
+		return node.getTypeDeclaration();
+	}
+
+	/**
+	 * Internal synonym for {@link MethodDeclaration#thrownExceptions()}. Use to alleviate deprecation warnings.
+	 *
+	 * @deprecated
+	 * @since 3.10
+	 */
+	@Deprecated
+	private static List<?> thrownExceptions(MethodDeclaration node) {
+		return node.thrownExceptions();
+	}
+
+	private class FunctionalEvalVisitor extends ASTVisitor {
+
+		/**
+		 * The string buffer into which the serialized representation of the AST is written.
+		 */
+		protected StringBuilder buffer = new StringBuilder();
+
+		private int indent = 2;
+
+		private Map<IBinding, String> localBindings = new HashMap<>();
+
+		public FunctionalEvalVisitor() {
+		}
+
+		boolean isLocalBinding(IBinding binding) {
+			return localBindings.containsKey(binding);
+		}
+
+		void addLocalBinding(IBinding binding, String name) {
+			localBindings.put(binding, name);
+		}
+
+		void printIndent() {
+			for (int i = 0; i < indent; i++) {
+				buffer.append("  ");//$NON-NLS-1$
+			}
+		}
+
+		/**
+		 * Internal synonym for {@link AST#JLS2}. Use to alleviate deprecation warnings.
+		 *
+		 * @deprecated
+		 */
+		@Deprecated
+		private static final int JLS2 = AST.JLS2;
+
+		/**
+		 * Internal synonym for {@link AST#JLS3}. Use to alleviate deprecation warnings.
+		 *
+		 * @deprecated
+		 */
+		@Deprecated
+		private static final int JLS3 = AST.JLS3;
+
+		/**
+		 * Internal synonym for {@link AST#JLS4}. Use to alleviate deprecation warnings.
+		 *
+		 * @deprecated
+		 */
+		@Deprecated
+		private static final int JLS4 = AST.JLS4;
+
+		/**
+		 * Internal synonym for {@link AST#JLS8}. Use to alleviate deprecation warnings.
+		 *
+		 * @deprecated
+		 */
+		@Deprecated
+		private static final int JLS8 = AST.JLS8;
+
+		/**
+		 * Internal synonym for {@link AST#JLS9}. Use to alleviate deprecation warnings.
+		 *
+		 * @deprecated
+		 */
+		@Deprecated
+		private static final int JLS9 = AST.JLS9;
+
+		/**
+		 * Internal synonym for {@link ClassInstanceCreation#getName()}. Use to alleviate deprecation warnings.
+		 *
+		 * @deprecated
+		 */
+		@Deprecated
+		private Name getName(ClassInstanceCreation node) {
+			return node.getName();
+		}
+
+		/**
+		 * Appends the text representation of the given modifier flags, followed by a single space. Used for JLS2 modifiers.
+		 *
+		 * @param modifiers
+		 *            the modifier flags
+		 */
+		void printModifiers(int modifiers) {
+			if (Modifier.isPublic(modifiers)) {
+				buffer.append("public ");//$NON-NLS-1$
+			}
+			if (Modifier.isProtected(modifiers)) {
+				buffer.append("protected ");//$NON-NLS-1$
+			}
+			if (Modifier.isPrivate(modifiers)) {
+				buffer.append("private ");//$NON-NLS-1$
+			}
+			if (Modifier.isStatic(modifiers)) {
+				buffer.append("static ");//$NON-NLS-1$
+			}
+			if (Modifier.isAbstract(modifiers)) {
+				buffer.append("abstract ");//$NON-NLS-1$
+			}
+			if (Modifier.isFinal(modifiers)) {
+				buffer.append("final ");//$NON-NLS-1$
+			}
+			if (Modifier.isSynchronized(modifiers)) {
+				buffer.append("synchronized ");//$NON-NLS-1$
+			}
+			if (Modifier.isVolatile(modifiers)) {
+				buffer.append("volatile ");//$NON-NLS-1$
+			}
+			if (Modifier.isNative(modifiers)) {
+				buffer.append("native ");//$NON-NLS-1$
+			}
+			if (Modifier.isStrictfp(modifiers)) {
+				buffer.append("strictfp ");//$NON-NLS-1$
+			}
+			if (Modifier.isTransient(modifiers)) {
+				buffer.append("transient ");//$NON-NLS-1$
+			}
+		}
+
+		/**
+		 * Appends the text representation of the given modifier flags, followed by a single space. Used for 3.0 modifiers and annotations.
+		 *
+		 * @param ext
+		 *            the list of modifier and annotation nodes (element type: <code>IExtendedModifiers</code>)
+		 */
+		void printModifiers(List ext) {
+			for (Iterator it = ext.iterator(); it.hasNext();) {
+				ASTNode p = (ASTNode) it.next();
+				p.accept(this);
+				buffer.append(" ");//$NON-NLS-1$
+			}
+		}
+
+		private void printTypes(List<Type> types, String prefix) {
+			if (types.size() > 0) {
+				buffer.append(" " + prefix + " ");//$NON-NLS-1$ //$NON-NLS-2$
+				Type type = types.get(0);
+				type.accept(this);
+				for (int i = 1, l = types.size(); i < l; ++i) {
+					buffer.append(","); //$NON-NLS-1$
+					type = types.get(0);
+					type.accept(this);
+				}
+			}
+		}
+
+		/**
+		 * reference node helper function that is common to all the difference reference nodes.
+		 *
+		 * @param typeArguments
+		 *            list of type arguments
+		 */
+		private void visitReferenceTypeArguments(List typeArguments) {
+			buffer.append("::");//$NON-NLS-1$
+			if (!typeArguments.isEmpty()) {
+				buffer.append('<');
+				for (Iterator it = typeArguments.iterator(); it.hasNext();) {
+					Type t = (Type) it.next();
+					t.accept(this);
+					if (it.hasNext()) {
+						buffer.append(',');
+					}
+				}
+				buffer.append('>');
+			}
+		}
+
+		private void visitTypeAnnotations(AnnotatableType node) {
+			if (node.getAST().apiLevel() >= JLS8) {
+				visitAnnotationsList(node.annotations());
+			}
+		}
+
+		private void visitAnnotationsList(List annotations) {
+			for (Iterator it = annotations.iterator(); it.hasNext();) {
+				Annotation annotation = (Annotation) it.next();
+				annotation.accept(this);
+				buffer.append(' ');
+			}
+		}
+
+		/**
+		 * Internal synonym for {@link TypeDeclaration#superInterfaces()}. Use to alleviate deprecation warnings.
+		 *
+		 * @deprecated
+		 * @since 3.4
+		 */
+		@Deprecated
+		private List superInterfaces(TypeDeclaration node) {
+			return node.superInterfaces();
+		}
+
+		@Override
+		public boolean visit(AnnotationTypeDeclaration node) {
+			if (node.getJavadoc() != null) {
+				node.getJavadoc().accept(this);
+			}
+			printIndent();
+			printModifiers(node.modifiers());
+			buffer.append("@interface ");//$NON-NLS-1$
+			node.getName().accept(this);
+			buffer.append(" {");//$NON-NLS-1$
+			for (Iterator it = node.bodyDeclarations().iterator(); it.hasNext();) {
+				BodyDeclaration d = (BodyDeclaration) it.next();
+				d.accept(this);
+			}
+			buffer.append("}\n");//$NON-NLS-1$
+			return false;
+		}
+
+		@Override
+		public boolean visit(AnnotationTypeMemberDeclaration node) {
+			if (node.getJavadoc() != null) {
+				node.getJavadoc().accept(this);
+			}
+			printIndent();
+			printModifiers(node.modifiers());
+			node.getType().accept(this);
+			buffer.append(" ");//$NON-NLS-1$
+			node.getName().accept(this);
+			buffer.append("()");//$NON-NLS-1$
+			if (node.getDefault() != null) {
+				buffer.append(" default ");//$NON-NLS-1$
+				node.getDefault().accept(this);
+			}
+			buffer.append(";\n");//$NON-NLS-1$
+			return false;
+		}
+
+		@Override
+		public boolean visit(AnonymousClassDeclaration node) {
+			buffer.append("{\n");//$NON-NLS-1$
+			indent++;
+			for (Iterator it = node.bodyDeclarations().iterator(); it.hasNext();) {
+				BodyDeclaration b = (BodyDeclaration) it.next();
+				b.accept(this);
+			}
+			indent--;
+			printIndent();
+			buffer.append("}\n");//$NON-NLS-1$
+			return false;
+		}
+
+		@Override
+		public boolean visit(ArrayAccess node) {
+			node.getArray().accept(this);
+			buffer.append("[");//$NON-NLS-1$
+			node.getIndex().accept(this);
+			buffer.append("]");//$NON-NLS-1$
+			return false;
+		}
+
+		@Override
+		public boolean visit(ArrayCreation node) {
+			buffer.append("new ");//$NON-NLS-1$
+			ArrayType at = node.getType();
+			int dims = at.getDimensions();
+			Type elementType = at.getElementType();
+			elementType.accept(this);
+			for (Iterator it = node.dimensions().iterator(); it.hasNext();) {
+				buffer.append("[");//$NON-NLS-1$
+				Expression e = (Expression) it.next();
+				e.accept(this);
+				buffer.append("]");//$NON-NLS-1$
+				dims--;
+			}
+			// add empty "[]" for each extra array dimension
+			for (int i = 0; i < dims; i++) {
+				buffer.append("[]");//$NON-NLS-1$
+			}
+			if (node.getInitializer() != null) {
+				node.getInitializer().accept(this);
+			}
+			return false;
+		}
+
+		@Override
+		public boolean visit(ArrayInitializer node) {
+			buffer.append("{");//$NON-NLS-1$
+			for (Iterator it = node.expressions().iterator(); it.hasNext();) {
+				Expression e = (Expression) it.next();
+				e.accept(this);
+				if (it.hasNext()) {
+					buffer.append(",");//$NON-NLS-1$
+				}
+			}
+			buffer.append("}");//$NON-NLS-1$
+			return false;
+		}
+
+		@Override
+		public boolean visit(ArrayType node) {
+			if (node.getAST().apiLevel() < JLS8) {
+				visitComponentType(node);
+				buffer.append("[]");//$NON-NLS-1$
+			} else {
+				node.getElementType().accept(this);
+				List dimensions = node.dimensions();
+				int size = dimensions.size();
+				for (int i = 0; i < size; i++) {
+					Dimension aDimension = (Dimension) dimensions.get(i);
+					aDimension.accept(this);
+				}
+			}
+			return false;
+		}
+
+		@Override
+		public boolean visit(AssertStatement node) {
+			printIndent();
+			buffer.append("assert ");//$NON-NLS-1$
+			node.getExpression().accept(this);
+			if (node.getMessage() != null) {
+				buffer.append(" : ");//$NON-NLS-1$
+				node.getMessage().accept(this);
+			}
+			buffer.append(";\n");//$NON-NLS-1$
+			return false;
+		}
+
+		@Override
+		public boolean visit(Assignment node) {
+			node.getLeftHandSide().accept(this);
+			buffer.append(node.getOperator().toString());
+			node.getRightHandSide().accept(this);
+			return false;
+		}
+
+		@Override
+		public boolean visit(Block node) {
+			buffer.append("{\n");//$NON-NLS-1$
+			indent++;
+			for (Iterator it = node.statements().iterator(); it.hasNext();) {
+				Statement s = (Statement) it.next();
+				s.accept(this);
+			}
+			indent--;
+			printIndent();
+			buffer.append("}\n");//$NON-NLS-1$
+			return false;
+		}
+
+		@Override
+		public boolean visit(BlockComment node) {
+			printIndent();
+			buffer.append("/* */");//$NON-NLS-1$
+			return false;
+		}
+
+		@Override
+		public boolean visit(BooleanLiteral node) {
+			if (node.booleanValue() == true) {
+				buffer.append("true");//$NON-NLS-1$
+			} else {
+				buffer.append("false");//$NON-NLS-1$
+			}
+			return false;
+		}
+
+		@Override
+		public boolean visit(BreakStatement node) {
+			printIndent();
+			buffer.append("break");//$NON-NLS-1$
+			if (node.getLabel() != null) {
+				buffer.append(" ");//$NON-NLS-1$
+				node.getLabel().accept(this);
+			}
+			buffer.append(";\n");//$NON-NLS-1$
+			return false;
+		}
+
+		@Override
+		public boolean visit(CastExpression node) {
+			//buffer.append("(");//$NON-NLS-1$
+			node.getType().accept(this);
+			//buffer.append(")");//$NON-NLS-1$
+			node.getExpression().accept(this);
+			return false;
+		}
+
+		@Override
+		public boolean visit(CatchClause node) {
+			buffer.append("catch (");//$NON-NLS-1$
+			node.getException().accept(this);
+			buffer.append(") ");//$NON-NLS-1$
+			node.getBody().accept(this);
+			return false;
+		}
+
+		@Override
+		public boolean visit(CharacterLiteral node) {
+			buffer.append(node.getEscapedValue());
+			return false;
+		}
+
+		@Override
+		public boolean visit(ClassInstanceCreation node) {
+			if (node.getExpression() != null) {
+				node.getExpression().accept(this);
+				buffer.append(".");//$NON-NLS-1$
+			}
+			buffer.append("new ");//$NON-NLS-1$
+			if (node.getAST().apiLevel() == JLS2) {
+				getName(node).accept(this);
+			}
+			if (node.getAST().apiLevel() >= JLS3) {
+				if (!node.typeArguments().isEmpty()) {
+					buffer.append("<");//$NON-NLS-1$
+					for (Iterator it = node.typeArguments().iterator(); it.hasNext();) {
+						Type t = (Type) it.next();
+						t.accept(this);
+						if (it.hasNext()) {
+							buffer.append(",");//$NON-NLS-1$
+						}
+					}
+					buffer.append(">");//$NON-NLS-1$
+				}
+				node.getType().accept(this);
+			}
+			buffer.append("(");//$NON-NLS-1$
+			for (Iterator it = node.arguments().iterator(); it.hasNext();) {
+				Expression e = (Expression) it.next();
+				e.accept(this);
+				if (it.hasNext()) {
+					buffer.append(",");//$NON-NLS-1$
+				}
+			}
+			buffer.append(")");//$NON-NLS-1$
+			if (node.getAnonymousClassDeclaration() != null) {
+				node.getAnonymousClassDeclaration().accept(this);
+			}
+			return false;
+		}
+
+		@Override
+		public boolean visit(CompilationUnit node) {
+			if (node.getAST().apiLevel() >= JLS9) {
+				if (node.getModule() != null) {
+					node.getModule().accept(this);
+				}
+			}
+			if (node.getPackage() != null) {
+				node.getPackage().accept(this);
+			}
+			for (Iterator it = node.imports().iterator(); it.hasNext();) {
+				ImportDeclaration d = (ImportDeclaration) it.next();
+				d.accept(this);
+			}
+			for (Iterator it = node.types().iterator(); it.hasNext();) {
+				AbstractTypeDeclaration d = (AbstractTypeDeclaration) it.next();
+				d.accept(this);
+			}
+			return false;
+		}
+
+		@Override
+		public boolean visit(ConditionalExpression node) {
+			node.getExpression().accept(this);
+			buffer.append(" ? ");//$NON-NLS-1$
+			node.getThenExpression().accept(this);
+			buffer.append(" : ");//$NON-NLS-1$
+			node.getElseExpression().accept(this);
+			return false;
+		}
+
+		@Override
+		public boolean visit(ConstructorInvocation node) {
+			printIndent();
+			if (node.getAST().apiLevel() >= JLS3) {
+				if (!node.typeArguments().isEmpty()) {
+					buffer.append("<");//$NON-NLS-1$
+					for (Iterator it = node.typeArguments().iterator(); it.hasNext();) {
+						Type t = (Type) it.next();
+						t.accept(this);
+						if (it.hasNext()) {
+							buffer.append(",");//$NON-NLS-1$
+						}
+					}
+					buffer.append(">");//$NON-NLS-1$
+				}
+			}
+			buffer.append("this(");//$NON-NLS-1$
+			for (Iterator it = node.arguments().iterator(); it.hasNext();) {
+				Expression e = (Expression) it.next();
+				e.accept(this);
+				if (it.hasNext()) {
+					buffer.append(",");//$NON-NLS-1$
+				}
+			}
+			buffer.append(");\n");//$NON-NLS-1$
+			return false;
+		}
+
+		@Override
+		public boolean visit(ContinueStatement node) {
+			printIndent();
+			buffer.append("continue");//$NON-NLS-1$
+			if (node.getLabel() != null) {
+				buffer.append(" ");//$NON-NLS-1$
+				node.getLabel().accept(this);
+			}
+			buffer.append(";\n");//$NON-NLS-1$
+			return false;
+		}
+
+		@Override
+		public boolean visit(CreationReference node) {
+			node.getType().accept(this);
+			visitReferenceTypeArguments(node.typeArguments());
+			buffer.append("new");//$NON-NLS-1$
+			return false;
+		}
+
+		@Override
+		public boolean visit(Dimension node) {
+			List annotations = node.annotations();
+			if (annotations.size() > 0) {
+				buffer.append(' ');
+			}
+			visitAnnotationsList(annotations);
+			buffer.append("[]"); //$NON-NLS-1$
+			return false;
+		}
+
+		@Override
+		public boolean visit(DoStatement node) {
+			printIndent();
+			buffer.append("do ");//$NON-NLS-1$
+			node.getBody().accept(this);
+			buffer.append(" while (");//$NON-NLS-1$
+			node.getExpression().accept(this);
+			buffer.append(");\n");//$NON-NLS-1$
+			return false;
+		}
+
+		@Override
+		public boolean visit(EmptyStatement node) {
+			printIndent();
+			buffer.append(";\n");//$NON-NLS-1$
+			return false;
+		}
+
+		@Override
+		public boolean visit(EnhancedForStatement node) {
+			printIndent();
+			buffer.append("for (");//$NON-NLS-1$
+			node.getParameter().accept(this);
+			buffer.append(" : ");//$NON-NLS-1$
+			node.getExpression().accept(this);
+			buffer.append(") ");//$NON-NLS-1$
+			node.getBody().accept(this);
+			return false;
+		}
+
+		@Override
+		public boolean visit(EnumConstantDeclaration node) {
+			if (node.getJavadoc() != null) {
+				node.getJavadoc().accept(this);
+			}
+			printIndent();
+			printModifiers(node.modifiers());
+			node.getName().accept(this);
+			if (!node.arguments().isEmpty()) {
+				buffer.append("(");//$NON-NLS-1$
+				for (Iterator it = node.arguments().iterator(); it.hasNext();) {
+					Expression e = (Expression) it.next();
+					e.accept(this);
+					if (it.hasNext()) {
+						buffer.append(",");//$NON-NLS-1$
+					}
+				}
+				buffer.append(")");//$NON-NLS-1$
+			}
+			if (node.getAnonymousClassDeclaration() != null) {
+				node.getAnonymousClassDeclaration().accept(this);
+			}
+			return false;
+		}
+
+		@Override
+		public boolean visit(EnumDeclaration node) {
+			if (node.getJavadoc() != null) {
+				node.getJavadoc().accept(this);
+			}
+			printIndent();
+			printModifiers(node.modifiers());
+			buffer.append("enum ");//$NON-NLS-1$
+			node.getName().accept(this);
+			buffer.append(" ");//$NON-NLS-1$
+			if (!node.superInterfaceTypes().isEmpty()) {
+				buffer.append("implements ");//$NON-NLS-1$
+				for (Iterator it = node.superInterfaceTypes().iterator(); it.hasNext();) {
+					Type t = (Type) it.next();
+					t.accept(this);
+					if (it.hasNext()) {
+						buffer.append(", ");//$NON-NLS-1$
+					}
+				}
+				buffer.append(" ");//$NON-NLS-1$
+			}
+			buffer.append("{");//$NON-NLS-1$
+			for (Iterator it = node.enumConstants().iterator(); it.hasNext();) {
+				EnumConstantDeclaration d = (EnumConstantDeclaration) it.next();
+				d.accept(this);
+				// enum constant declarations do not include punctuation
+				if (it.hasNext()) {
+					// enum constant declarations are separated by commas
+					buffer.append(", ");//$NON-NLS-1$
+				}
+			}
+			if (!node.bodyDeclarations().isEmpty()) {
+				buffer.append("; ");//$NON-NLS-1$
+				for (Iterator it = node.bodyDeclarations().iterator(); it.hasNext();) {
+					BodyDeclaration d = (BodyDeclaration) it.next();
+					d.accept(this);
+					// other body declarations include trailing punctuation
+				}
+			}
+			buffer.append("}\n");//$NON-NLS-1$
+			return false;
+		}
+
+		@Override
+		public boolean visit(ExportsDirective node) {
+			return visit(node, "exports"); //$NON-NLS-1$
+		}
+
+		@Override
+		public boolean visit(ExpressionMethodReference node) {
+			node.getExpression().accept(this);
+			visitReferenceTypeArguments(node.typeArguments());
+			node.getName().accept(this);
+			return false;
+		}
+
+		@Override
+		public boolean visit(ExpressionStatement node) {
+			printIndent();
+			node.getExpression().accept(this);
+			buffer.append(";\n");//$NON-NLS-1$
+			return false;
+		}
+
+		@Override
+		public boolean visit(FieldAccess node) {
+			/* TODO: Make tricks here when we access fields where we have non-public access */
+			ITypeBinding instanceType = node.getExpression().resolveTypeBinding();
+			if (instanceType.isAssignmentCompatible(RemoteEvaluatorBuilder.this.enclosingClass)) {
+				node.getExpression().accept(this);
+				buffer.append(".");//$NON-NLS-1$ */
+				buffer.append(node.getName().getIdentifier());
+				return false;
+			}
+			node.getExpression().accept(this);
+			buffer.append(".");//$NON-NLS-1$
+			node.getName().accept(this);
+			return false;
+		}
+
+		@Override
+		public boolean visit(FieldDeclaration node) {
+			if (node.getJavadoc() != null) {
+				node.getJavadoc().accept(this);
+			}
+			printIndent();
+			if (node.getAST().apiLevel() == JLS2) {
+				printModifiers(node.getModifiers());
+			}
+			if (node.getAST().apiLevel() >= JLS3) {
+				printModifiers(node.modifiers());
+			}
+			node.getType().accept(this);
+			buffer.append(" ");//$NON-NLS-1$
+			for (Iterator it = node.fragments().iterator(); it.hasNext();) {
+				VariableDeclarationFragment f = (VariableDeclarationFragment) it.next();
+				f.accept(this);
+				if (it.hasNext()) {
+					buffer.append(", ");//$NON-NLS-1$
+				}
+			}
+			buffer.append(";\n");//$NON-NLS-1$
+			return false;
+		}
+
+		@Override
+		public boolean visit(ForStatement node) {
+			printIndent();
+			buffer.append("for (");//$NON-NLS-1$
+			for (Iterator it = node.initializers().iterator(); it.hasNext();) {
+				Expression e = (Expression) it.next();
+				e.accept(this);
+				if (it.hasNext()) {
+					buffer.append(", ");//$NON-NLS-1$
+				}
+			}
+			buffer.append("; ");//$NON-NLS-1$
+			if (node.getExpression() != null) {
+				node.getExpression().accept(this);
+			}
+			buffer.append("; ");//$NON-NLS-1$
+			for (Iterator it = node.updaters().iterator(); it.hasNext();) {
+				Expression e = (Expression) it.next();
+				e.accept(this);
+				if (it.hasNext()) {
+					buffer.append(", ");//$NON-NLS-1$
+				}
+			}
+			buffer.append(") ");//$NON-NLS-1$
+			node.getBody().accept(this);
+			return false;
+		}
+
+		@Override
+		public boolean visit(IfStatement node) {
+			printIndent();
+			buffer.append("if (");//$NON-NLS-1$
+			node.getExpression().accept(this);
+			buffer.append(") ");//$NON-NLS-1$
+			node.getThenStatement().accept(this);
+			if (node.getElseStatement() != null) {
+				buffer.append(" else ");//$NON-NLS-1$
+				node.getElseStatement().accept(this);
+			}
+			return false;
+		}
+
+		@Override
+		public boolean visit(ImportDeclaration node) {
+			printIndent();
+			buffer.append("import ");//$NON-NLS-1$
+			if (node.getAST().apiLevel() >= JLS3) {
+				if (node.isStatic()) {
+					buffer.append("static ");//$NON-NLS-1$
+				}
+			}
+			node.getName().accept(this);
+			if (node.isOnDemand()) {
+				buffer.append(".*");//$NON-NLS-1$
+			}
+			buffer.append(";\n");//$NON-NLS-1$
+			return false;
+		}
+
+		@Override
+		public boolean visit(InfixExpression node) {
+			node.getLeftOperand().accept(this);
+			buffer.append(' '); // for cases like x= i - -1; or x= i++ + ++i;
+			buffer.append(node.getOperator().toString());
+			buffer.append(' ');
+			node.getRightOperand().accept(this);
+			final List extendedOperands = node.extendedOperands();
+			if (extendedOperands.size() != 0) {
+				buffer.append(' ');
+				for (Iterator it = extendedOperands.iterator(); it.hasNext();) {
+					buffer.append(node.getOperator().toString()).append(' ');
+					Expression e = (Expression) it.next();
+					e.accept(this);
+				}
+			}
+			return false;
+		}
+
+		@Override
+		public boolean visit(Initializer node) {
+			if (node.getJavadoc() != null) {
+				node.getJavadoc().accept(this);
+			}
+			if (node.getAST().apiLevel() == JLS2) {
+				printModifiers(node.getModifiers());
+			}
+			if (node.getAST().apiLevel() >= JLS3) {
+				printModifiers(node.modifiers());
+			}
+			node.getBody().accept(this);
+			return false;
+		}
+
+		@Override
+		public boolean visit(InstanceofExpression node) {
+			node.getLeftOperand().accept(this);
+			buffer.append(" instanceof ");//$NON-NLS-1$
+			node.getRightOperand().accept(this);
+			return false;
+		}
+
+		@Override
+		public boolean visit(IntersectionType node) {
+			for (Iterator it = node.types().iterator(); it.hasNext();) {
+				Type t = (Type) it.next();
+				t.accept(this);
+				if (it.hasNext()) {
+					buffer.append(" & "); //$NON-NLS-1$
+				}
+			}
+			return false;
+		}
+
+		@Override
+		public boolean visit(Javadoc node) {
+			printIndent();
+			buffer.append("/** ");//$NON-NLS-1$
+			for (Iterator it = node.tags().iterator(); it.hasNext();) {
+				ASTNode e = (ASTNode) it.next();
+				e.accept(this);
+			}
+			buffer.append("\n */\n");//$NON-NLS-1$
+			return false;
+		}
+
+		@Override
+		public boolean visit(LabeledStatement node) {
+			printIndent();
+			node.getLabel().accept(this);
+			buffer.append(": ");//$NON-NLS-1$
+			node.getBody().accept(this);
+			return false;
+		}
+
+		@Override
+		public boolean visit(LambdaExpression node) {
+			boolean hasParentheses = node.hasParentheses();
+			if (hasParentheses) {
+				buffer.append('(');
+			}
+			for (Iterator it = node.parameters().iterator(); it.hasNext();) {
+				VariableDeclaration v = (VariableDeclaration) it.next();
+				v.accept(this);
+				if (it.hasNext()) {
+					buffer.append(",");//$NON-NLS-1$
+				}
+			}
+			if (hasParentheses) {
+				buffer.append(')');
+			}
+			buffer.append(" -> "); //$NON-NLS-1$
+			node.getBody().accept(this);
+			return false;
+		}
+
+		@Override
+		public boolean visit(LineComment node) {
+			buffer.append("//\n");//$NON-NLS-1$
+			return false;
+		}
+
+		@Override
+		public boolean visit(MarkerAnnotation node) {
+			buffer.append("@");//$NON-NLS-1$
+			node.getTypeName().accept(this);
+			return false;
+		}
+
+		@Override
+		public boolean visit(MemberRef node) {
+			if (node.getQualifier() != null) {
+				node.getQualifier().accept(this);
+			}
+			buffer.append("#");//$NON-NLS-1$
+			node.getName().accept(this);
+			return false;
+		}
+
+		@Override
+		public boolean visit(MemberValuePair node) {
+			node.getName().accept(this);
+			buffer.append("=");//$NON-NLS-1$
+			node.getValue().accept(this);
+			return false;
+		}
+
+		@Override
+		public boolean visit(MethodDeclaration node) {
+			if (node.getJavadoc() != null) {
+				node.getJavadoc().accept(this);
+			}
+			printIndent();
+			if (node.getAST().apiLevel() == JLS2) {
+				printModifiers(node.getModifiers());
+			}
+			if (node.getAST().apiLevel() >= JLS3) {
+				printModifiers(node.modifiers());
+				if (!node.typeParameters().isEmpty()) {
+					buffer.append("<");//$NON-NLS-1$
+					for (Iterator it = node.typeParameters().iterator(); it.hasNext();) {
+						TypeParameter t = (TypeParameter) it.next();
+						t.accept(this);
+						if (it.hasNext()) {
+							buffer.append(",");//$NON-NLS-1$
+						}
+					}
+					buffer.append(">");//$NON-NLS-1$
+				}
+			}
+			if (!node.isConstructor()) {
+				if (node.getAST().apiLevel() == JLS2) {
+					getReturnType(node).accept(this);
+				} else {
+					if (node.getReturnType2() != null) {
+						node.getReturnType2().accept(this);
+					} else {
+						// methods really ought to have a return type
+						buffer.append("void");//$NON-NLS-1$
+					}
+				}
+				buffer.append(" ");//$NON-NLS-1$
+			}
+			node.getName().accept(this);
+			buffer.append("(");//$NON-NLS-1$
+			if (node.getAST().apiLevel() >= JLS8) {
+				Type receiverType = node.getReceiverType();
+				if (receiverType != null) {
+					receiverType.accept(this);
+					buffer.append(' ');
+					SimpleName qualifier = node.getReceiverQualifier();
+					if (qualifier != null) {
+						qualifier.accept(this);
+						buffer.append('.');
+					}
+					buffer.append("this"); //$NON-NLS-1$
+					if (node.parameters().size() > 0) {
+						buffer.append(',');
+					}
+				}
+			}
+			for (Iterator it = node.parameters().iterator(); it.hasNext();) {
+				SingleVariableDeclaration v = (SingleVariableDeclaration) it.next();
+				v.accept(this);
+				if (it.hasNext()) {
+					buffer.append(",");//$NON-NLS-1$
+				}
+			}
+			buffer.append(")");//$NON-NLS-1$
+			int size = node.getExtraDimensions();
+			if (node.getAST().apiLevel() >= JLS8) {
+				List dimensions = node.extraDimensions();
+				for (int i = 0; i < size; i++) {
+					visit((Dimension) dimensions.get(i));
+				}
+			} else {
+				for (int i = 0; i < size; i++) {
+					buffer.append("[]"); //$NON-NLS-1$
+				}
+			}
+			if (node.getAST().apiLevel() < JLS8) {
+				if (!thrownExceptions(node).isEmpty()) {
+					buffer.append(" throws ");//$NON-NLS-1$
+					for (Iterator it = thrownExceptions(node).iterator(); it.hasNext();) {
+						Name n = (Name) it.next();
+						n.accept(this);
+						if (it.hasNext()) {
+							buffer.append(", ");//$NON-NLS-1$
+						}
+					}
+					buffer.append(" ");//$NON-NLS-1$
+				}
+			} else {
+				if (!node.thrownExceptionTypes().isEmpty()) {
+					buffer.append(" throws ");//$NON-NLS-1$
+					for (Iterator it = node.thrownExceptionTypes().iterator(); it.hasNext();) {
+						Type n = (Type) it.next();
+						n.accept(this);
+						if (it.hasNext()) {
+							buffer.append(", ");//$NON-NLS-1$
+						}
+					}
+					buffer.append(" ");//$NON-NLS-1$
+				}
+			}
+			if (node.getBody() == null) {
+				buffer.append(";\n");//$NON-NLS-1$
+			} else {
+				node.getBody().accept(this);
+			}
+			return false;
+		}
+
+		@Override
+		public boolean visit(MethodInvocation node) {
+			if (node.getExpression() != null) {
+				node.getExpression().accept(this);
+				buffer.append(".");//$NON-NLS-1$
+			} else {
+				String newVarName = new String(LOCAL_VAR_PREFIX) + allocateNewVariable(node.resolveMethodBinding().getDeclaringClass(), "this"); //$NON-NLS-1$
+				binder.bindThis(RemoteEvaluatorBuilder.this.enclosingClass, newVarName);
+				// buffer.append("this."); //$NON-NLS-1$
+				buffer.append(newVarName);
+				buffer.append(".");//$NON-NLS-1$
+			}
+			if (node.getAST().apiLevel() >= JLS3) {
+				if (!node.typeArguments().isEmpty()) {
+					buffer.append("<");//$NON-NLS-1$
+					for (Iterator it = node.typeArguments().iterator(); it.hasNext();) {
+						Type t = (Type) it.next();
+						t.accept(this);
+						if (it.hasNext()) {
+							buffer.append(",");//$NON-NLS-1$
+						}
+					}
+					buffer.append(">");//$NON-NLS-1$
+				}
+			}
+			node.getName().accept(this);
+			buffer.append("(");//$NON-NLS-1$
+			for (Iterator it = node.arguments().iterator(); it.hasNext();) {
+				Expression e = (Expression) it.next();
+				e.accept(this);
+				if (it.hasNext()) {
+					buffer.append(",");//$NON-NLS-1$
+				}
+			}
+			buffer.append(")");//$NON-NLS-1$
+			return false;
+		}
+
+		@Override
+		public boolean visit(MethodRef node) {
+			if (node.getQualifier() != null) {
+				node.getQualifier().accept(this);
+			}
+			buffer.append("#");//$NON-NLS-1$
+			node.getName().accept(this);
+			buffer.append("(");//$NON-NLS-1$
+			for (Iterator it = node.parameters().iterator(); it.hasNext();) {
+				MethodRefParameter e = (MethodRefParameter) it.next();
+				e.accept(this);
+				if (it.hasNext()) {
+					buffer.append(",");//$NON-NLS-1$
+				}
+			}
+			buffer.append(")");//$NON-NLS-1$
+			return false;
+		}
+
+		@Override
+		public boolean visit(MethodRefParameter node) {
+			node.getType().accept(this);
+			if (node.getAST().apiLevel() >= JLS3) {
+				if (node.isVarargs()) {
+					buffer.append("...");//$NON-NLS-1$
+				}
+			}
+			if (node.getName() != null) {
+				buffer.append(" ");//$NON-NLS-1$
+				node.getName().accept(this);
+			}
+			return false;
+		}
+
+		@Override
+		public boolean visit(Modifier node) {
+			buffer.append(node.getKeyword().toString());
+			return false;
+		}
+
+		@Override
+		public boolean visit(ModuleDeclaration node) {
+			if (node.getJavadoc() != null) {
+				node.getJavadoc().accept(this);
+			}
+			printModifiers(node.annotations());
+			if (node.isOpen()) {
+				buffer.append("open "); //$NON-NLS-1$
+			}
+			buffer.append("module"); //$NON-NLS-1$
+			buffer.append(" "); //$NON-NLS-1$
+			node.getName().accept(this);
+			buffer.append(" {\n"); //$NON-NLS-1$
+			indent++;
+			for (ModuleDirective stmt : (List<ModuleDirective>) node.moduleStatements()) {
+				stmt.accept(this);
+			}
+			indent--;
+			buffer.append("}"); //$NON-NLS-1$
+			return false;
+		}
+
+		@Override
+		/*
+		 * @see ASTVisitor#visit(ModuleModifier)
+		 *
+		 * @since 3.14
+		 */
+		public boolean visit(ModuleModifier node) {
+			buffer.append(node.getKeyword().toString());
+			return false;
+		}
+
+		private boolean visit(ModulePackageAccess node, String keyword) {
+			printIndent();
+			buffer.append(keyword);
+			buffer.append(" ");//$NON-NLS-1$
+			node.getName().accept(this);
+			printTypes(node.modules(), "to"); //$NON-NLS-1$
+			buffer.append(";\n");//$NON-NLS-1$
+			return false;
+		}
+
+		@Override
+		public boolean visit(NameQualifiedType node) {
+			node.getQualifier().accept(this);
+			buffer.append('.');
+			visitTypeAnnotations(node);
+			node.getName().accept(this);
+			return false;
+		}
+
+		@Override
+		public boolean visit(NormalAnnotation node) {
+			buffer.append("@");//$NON-NLS-1$
+			node.getTypeName().accept(this);
+			buffer.append("(");//$NON-NLS-1$
+			for (Iterator it = node.values().iterator(); it.hasNext();) {
+				MemberValuePair p = (MemberValuePair) it.next();
+				p.accept(this);
+				if (it.hasNext()) {
+					buffer.append(",");//$NON-NLS-1$
+				}
+			}
+			buffer.append(")");//$NON-NLS-1$
+			return false;
+		}
+
+		@Override
+		public boolean visit(NullLiteral node) {
+			buffer.append("null");//$NON-NLS-1$
+			return false;
+		}
+
+		@Override
+		public boolean visit(NumberLiteral node) {
+			buffer.append(node.getToken());
+			return false;
+		}
+
+		@Override
+		public boolean visit(OpensDirective node) {
+			return visit(node, "opens"); //$NON-NLS-1$
+		}
+
+		@Override
+		public boolean visit(PackageDeclaration node) {
+			if (node.getAST().apiLevel() >= JLS3) {
+				if (node.getJavadoc() != null) {
+					node.getJavadoc().accept(this);
+				}
+				for (Iterator it = node.annotations().iterator(); it.hasNext();) {
+					Annotation p = (Annotation) it.next();
+					p.accept(this);
+					buffer.append(" ");//$NON-NLS-1$
+				}
+			}
+			printIndent();
+			buffer.append("package ");//$NON-NLS-1$
+			node.getName().accept(this);
+			buffer.append(";\n");//$NON-NLS-1$
+			return false;
+		}
+
+		@Override
+		public boolean visit(ParameterizedType node) {
+			node.getType().accept(this);
+			buffer.append("<");//$NON-NLS-1$
+			for (Iterator it = node.typeArguments().iterator(); it.hasNext();) {
+				Type t = (Type) it.next();
+				t.accept(this);
+				if (it.hasNext()) {
+					buffer.append(",");//$NON-NLS-1$
+				}
+			}
+			buffer.append(">");//$NON-NLS-1$
+			return false;
+		}
+
+		@Override
+		public boolean visit(ParenthesizedExpression node) {
+			buffer.append("(");//$NON-NLS-1$
+			node.getExpression().accept(this);
+			buffer.append(")");//$NON-NLS-1$
+			return false;
+		}
+
+		@Override
+		public boolean visit(PostfixExpression node) {
+			node.getOperand().accept(this);
+			buffer.append(node.getOperator().toString());
+			return false;
+		}
+
+		@Override
+		public boolean visit(PrefixExpression node) {
+			buffer.append(node.getOperator().toString());
+			node.getOperand().accept(this);
+			return false;
+		}
+
+		@Override
+		public boolean visit(PrimitiveType node) {
+			visitTypeAnnotations(node);
+			buffer.append(node.getPrimitiveTypeCode().toString());
+			return false;
+		}
+
+		@Override
+		public boolean visit(ProvidesDirective node) {
+			printIndent();
+			buffer.append("provides");//$NON-NLS-1$
+			buffer.append(" ");//$NON-NLS-1$
+			node.getName().accept(this);
+			printTypes(node.implementations(), "with"); //$NON-NLS-1$
+			buffer.append(";\n");//$NON-NLS-1$
+			return false;
+		}
+
+		@Override
+		public boolean visit(QualifiedName node) {
+			node.getQualifier().accept(this);
+			buffer.append(".");//$NON-NLS-1$
+			node.getName().accept(this);
+			return false;
+		}
+
+		@Override
+		public boolean visit(QualifiedType node) {
+			node.getQualifier().accept(this);
+			buffer.append(".");//$NON-NLS-1$
+			visitTypeAnnotations(node);
+			node.getName().accept(this);
+			return false;
+		}
+
+		@Override
+		public boolean visit(RequiresDirective node) {
+			printIndent();
+			buffer.append("requires");//$NON-NLS-1$
+			buffer.append(" ");//$NON-NLS-1$
+			printModifiers(node.modifiers());
+			node.getName().accept(this);
+			buffer.append(";\n");//$NON-NLS-1$
+			return false;
+		}
+
+		@Override
+		public boolean visit(ReturnStatement node) {
+			printIndent();
+			buffer.append("return");//$NON-NLS-1$
+			if (node.getExpression() != null) {
+				buffer.append(" ");//$NON-NLS-1$
+				node.getExpression().accept(this);
+			}
+			buffer.append(";\n");//$NON-NLS-1$
+			return false;
+		}
+
+		@Override
+		public boolean visit(SimpleName node) {
+			IBinding binding = node.resolveBinding();
+			if (!isLocalBinding(binding)) {
+				if (binding instanceof IVariableBinding) {
+					IVariableBinding vb = ((IVariableBinding) binding);
+					// For future optimization: Check for duplicates, so same value is only bound once
+					if (vb.isField()) {
+						if (Modifier.isStatic(vb.getModifiers())) {
+							ITypeBinding declaringClass = vb.getDeclaringClass();
+							buffer.append(declaringClass.getQualifiedName());
+							buffer.append("."); //$NON-NLS-1$
+							buffer.append(node.getIdentifier());
+
+						} else {
+							// TODO: Fix this to use same method as visit(FieldAccess)
+							ITypeBinding declaringClass = vb.getDeclaringClass();
+							String newVarName = new String(LOCAL_VAR_PREFIX) + allocateNewVariable(declaringClass, "this"); //$NON-NLS-1$
+							binder.bindThis(declaringClass, newVarName);
+							// buffer.append("this."); //$NON-NLS-1$
+							buffer.append(newVarName);
+							buffer.append("."); //$NON-NLS-1$
+							buffer.append(node.getIdentifier());
+						}
+					} else {
+						String newVarName = new String(LOCAL_VAR_PREFIX) + allocateNewVariable(vb.getType(), node.getIdentifier());
+						binder.bind((IVariableBinding) binding, newVarName);
+						// buffer.append("this."); //$NON-NLS-1$
+						buffer.append(newVarName);
+					}
+					return false;
+				}
+			}
+
+			buffer.append(node.getIdentifier());
+			return false;
+		}
+
+		@Override
+		public boolean visit(SimpleType node) {
+			visitTypeAnnotations(node);
+			node.getName().accept(this);
+			return false;
+		}
+
+		@Override
+		public boolean visit(SingleMemberAnnotation node) {
+			buffer.append("@");//$NON-NLS-1$
+			node.getTypeName().accept(this);
+			buffer.append("(");//$NON-NLS-1$
+			node.getValue().accept(this);
+			buffer.append(")");//$NON-NLS-1$
+			return false;
+		}
+
+		@Override
+		public boolean visit(SingleVariableDeclaration node) {
+			printIndent();
+			if (node.getAST().apiLevel() == JLS2) {
+				printModifiers(node.getModifiers());
+			}
+			if (node.getAST().apiLevel() >= JLS3) {
+				printModifiers(node.modifiers());
+			}
+			node.getType().accept(this);
+			if (node.getAST().apiLevel() >= JLS3) {
+				if (node.isVarargs()) {
+					if (node.getAST().apiLevel() >= JLS8) {
+						List annotations = node.varargsAnnotations();
+						if (annotations.size() > 0) {
+							buffer.append(' ');
+						}
+						visitAnnotationsList(annotations);
+					}
+					buffer.append("...");//$NON-NLS-1$
+				}
+			}
+			buffer.append(" ");//$NON-NLS-1$
+			node.getName().accept(this);
+			int size = node.getExtraDimensions();
+			if (node.getAST().apiLevel() >= JLS8) {
+				List dimensions = node.extraDimensions();
+				for (int i = 0; i < size; i++) {
+					visit((Dimension) dimensions.get(i));
+				}
+			} else {
+				for (int i = 0; i < size; i++) {
+					buffer.append("[]"); //$NON-NLS-1$
+				}
+			}
+			if (node.getInitializer() != null) {
+				buffer.append("=");//$NON-NLS-1$
+				node.getInitializer().accept(this);
+			}
+			return false;
+		}
+
+		@Override
+		public boolean visit(StringLiteral node) {
+			buffer.append(node.getEscapedValue());
+			return false;
+		}
+
+		@Override
+		public boolean visit(SuperConstructorInvocation node) {
+			printIndent();
+			if (node.getExpression() != null) {
+				node.getExpression().accept(this);
+				buffer.append(".");//$NON-NLS-1$
+			}
+			if (node.getAST().apiLevel() >= JLS3) {
+				if (!node.typeArguments().isEmpty()) {
+					buffer.append("<");//$NON-NLS-1$
+					for (Iterator it = node.typeArguments().iterator(); it.hasNext();) {
+						Type t = (Type) it.next();
+						t.accept(this);
+						if (it.hasNext()) {
+							buffer.append(",");//$NON-NLS-1$
+						}
+					}
+					buffer.append(">");//$NON-NLS-1$
+				}
+			}
+			buffer.append("super(");//$NON-NLS-1$
+			for (Iterator it = node.arguments().iterator(); it.hasNext();) {
+				Expression e = (Expression) it.next();
+				e.accept(this);
+				if (it.hasNext()) {
+					buffer.append(",");//$NON-NLS-1$
+				}
+			}
+			buffer.append(");\n");//$NON-NLS-1$
+			return false;
+		}
+
+		@Override
+		public boolean visit(SuperFieldAccess node) {
+			if (node.getQualifier() != null) {
+				node.getQualifier().accept(this);
+				buffer.append(".");//$NON-NLS-1$
+			}
+			buffer.append("super.");//$NON-NLS-1$
+			node.getName().accept(this);
+			return false;
+		}
+
+		@Override
+		public boolean visit(SuperMethodInvocation node) {
+			if (node.getQualifier() != null) {
+				node.getQualifier().accept(this);
+				buffer.append(".");//$NON-NLS-1$
+			}
+			buffer.append("super.");//$NON-NLS-1$
+			if (node.getAST().apiLevel() >= JLS3) {
+				if (!node.typeArguments().isEmpty()) {
+					buffer.append("<");//$NON-NLS-1$
+					for (Iterator it = node.typeArguments().iterator(); it.hasNext();) {
+						Type t = (Type) it.next();
+						t.accept(this);
+						if (it.hasNext()) {
+							buffer.append(",");//$NON-NLS-1$
+						}
+					}
+					buffer.append(">");//$NON-NLS-1$
+				}
+			}
+			node.getName().accept(this);
+			buffer.append("(");//$NON-NLS-1$
+			for (Iterator it = node.arguments().iterator(); it.hasNext();) {
+				Expression e = (Expression) it.next();
+				e.accept(this);
+				if (it.hasNext()) {
+					buffer.append(",");//$NON-NLS-1$
+				}
+			}
+			buffer.append(")");//$NON-NLS-1$
+			return false;
+		}
+
+		/*
+		 * @see ASTVisitor#visit(SuperMethodReference)
+		 *
+		 * @since 3.10
+		 */
+		@Override
+		public boolean visit(SuperMethodReference node) {
+			if (node.getQualifier() != null) {
+				node.getQualifier().accept(this);
+				buffer.append('.');
+			}
+			buffer.append("super");//$NON-NLS-1$
+			visitReferenceTypeArguments(node.typeArguments());
+			node.getName().accept(this);
+			return false;
+		}
+
+		@Override
+		public boolean visit(SwitchCase node) {
+			if ((node.getAST().isPreviewEnabled())) {
+				if (node.isDefault()) {
+					buffer.append("default");//$NON-NLS-1$
+					buffer.append(node.isSwitchLabeledRule() ? " ->" : ":");//$NON-NLS-1$ //$NON-NLS-2$
+				} else {
+					buffer.append("case ");//$NON-NLS-1$
+					for (Iterator it = node.expressions().iterator(); it.hasNext();) {
+						Expression t = (Expression) it.next();
+						t.accept(this);
+						buffer.append(it.hasNext() ? ", " : //$NON-NLS-1$
+								node.isSwitchLabeledRule() ? " ->" : ":");//$NON-NLS-1$ //$NON-NLS-2$
+					}
+				}
+			} else {
+				if (node.isDefault()) {
+					buffer.append("default :\n");//$NON-NLS-1$
+				} else {
+					buffer.append("case ");//$NON-NLS-1$
+					getSwitchExpression(node).accept(this);
+					buffer.append(":\n");//$NON-NLS-1$
+				}
+			}
+			indent++; // decremented in visit(SwitchStatement)
+			return false;
+		}
+
+		/**
+		 * @deprecated
+		 */
+		@Deprecated
+		private Expression getSwitchExpression(SwitchCase node) {
+			return node.getExpression();
+		}
+
+		private void visitSwitchNode(ASTNode node) {
+			buffer.append("switch (");//$NON-NLS-1$
+			if (node instanceof SwitchExpression) {
+				((SwitchExpression) node).getExpression().accept(this);
+			} else if (node instanceof SwitchStatement) {
+				((SwitchStatement) node).getExpression().accept(this);
+			}
+			buffer.append(") ");//$NON-NLS-1$
+			buffer.append("{\n");//$NON-NLS-1$
+			indent++;
+			if (node instanceof SwitchExpression) {
+				for (Iterator it = ((SwitchExpression) node).statements().iterator(); it.hasNext();) {
+					Statement s = (Statement) it.next();
+					s.accept(this);
+					indent--; // incremented in visit(SwitchCase)
+				}
+			} else if (node instanceof SwitchStatement) {
+				for (Iterator it = ((SwitchStatement) node).statements().iterator(); it.hasNext();) {
+					Statement s = (Statement) it.next();
+					s.accept(this);
+					indent--; // incremented in visit(SwitchCase)
+				}
+			}
+			indent--;
+			printIndent();
+			buffer.append("}\n");//$NON-NLS-1$
+
+		}
+
+		@Override
+		public boolean visit(SwitchExpression node) {
+			visitSwitchNode(node);
+			return false;
+		}
+
+		@Override
+		public boolean visit(SwitchStatement node) {
+			visitSwitchNode(node);
+			return false;
+		}
+
+		@Override
+		public boolean visit(SynchronizedStatement node) {
+			buffer.append("synchronized (");//$NON-NLS-1$
+			node.getExpression().accept(this);
+			buffer.append(") ");//$NON-NLS-1$
+			node.getBody().accept(this);
+			return false;
+		}
+
+		@Override
+		public boolean visit(TagElement node) {
+			return false;
+		}
+
+		@Override
+		public boolean visit(TextBlock node) {
+			buffer.append(node.getEscapedValue());
+			return false;
+		}
+
+		@Override
+		public boolean visit(TextElement node) {
+			buffer.append(node.getText());
+			return false;
+		}
+
+		@Override
+		public boolean visit(ThisExpression node) {
+			ITypeBinding thisType = node.resolveTypeBinding();
+
+			String newVarName = new String(LOCAL_VAR_PREFIX) + allocateNewVariable(thisType, "this"); //$NON-NLS-1$
+			binder.bindThis(thisType, newVarName);
+			// buffer.append("this."); //$NON-NLS-1$
+			buffer.append(newVarName);
+			return false;
+		}
+
+		@Override
+		public boolean visit(ThrowStatement node) {
+			printIndent();
+			buffer.append("throw ");//$NON-NLS-1$
+			node.getExpression().accept(this);
+			buffer.append(";\n");//$NON-NLS-1$
+			return false;
+		}
+
+		@Override
+		public boolean visit(TryStatement node) {
+			printIndent();
+			buffer.append("try ");//$NON-NLS-1$
+			if (node.getAST().apiLevel() >= JLS4) {
+				List resources = node.resources();
+				if (!resources.isEmpty()) {
+					buffer.append('(');
+					for (Iterator it = resources.iterator(); it.hasNext();) {
+						Expression variable = (Expression) it.next();
+						variable.accept(this);
+						if (it.hasNext()) {
+							buffer.append(';');
+						}
+					}
+					buffer.append(')');
+				}
+			}
+			node.getBody().accept(this);
+			buffer.append(" ");//$NON-NLS-1$
+			for (Iterator it = node.catchClauses().iterator(); it.hasNext();) {
+				CatchClause cc = (CatchClause) it.next();
+				cc.accept(this);
+			}
+			if (node.getFinally() != null) {
+				buffer.append(" finally ");//$NON-NLS-1$
+				node.getFinally().accept(this);
+			}
+			return false;
+		}
+
+		@Override
+		public boolean visit(TypeDeclaration node) {
+			if (node.getJavadoc() != null) {
+				node.getJavadoc().accept(this);
+			}
+			if (node.getAST().apiLevel() == JLS2) {
+				printModifiers(node.getModifiers());
+			}
+			if (node.getAST().apiLevel() >= JLS3) {
+				printModifiers(node.modifiers());
+			}
+			buffer.append(node.isInterface() ? "interface " : "class ");//$NON-NLS-2$//$NON-NLS-1$
+			node.getName().accept(this);
+			if (node.getAST().apiLevel() >= JLS3) {
+				if (!node.typeParameters().isEmpty()) {
+					buffer.append("<");//$NON-NLS-1$
+					for (Iterator it = node.typeParameters().iterator(); it.hasNext();) {
+						TypeParameter t = (TypeParameter) it.next();
+						t.accept(this);
+						if (it.hasNext()) {
+							buffer.append(",");//$NON-NLS-1$
+						}
+					}
+					buffer.append(">");//$NON-NLS-1$
+				}
+			}
+			buffer.append(" ");//$NON-NLS-1$
+			if (node.getAST().apiLevel() == JLS2) {
+				if (getSuperclass(node) != null) {
+					buffer.append("extends ");//$NON-NLS-1$
+					getSuperclass(node).accept(this);
+					buffer.append(" ");//$NON-NLS-1$
+				}
+				if (!superInterfaces(node).isEmpty()) {
+					buffer.append(node.isInterface() ? "extends " : "implements ");//$NON-NLS-2$//$NON-NLS-1$
+					for (Iterator it = superInterfaces(node).iterator(); it.hasNext();) {
+						Name n = (Name) it.next();
+						n.accept(this);
+						if (it.hasNext()) {
+							buffer.append(", ");//$NON-NLS-1$
+						}
+					}
+					buffer.append(" ");//$NON-NLS-1$
+				}
+			}
+			if (node.getAST().apiLevel() >= JLS3) {
+				if (node.getSuperclassType() != null) {
+					buffer.append("extends ");//$NON-NLS-1$
+					node.getSuperclassType().accept(this);
+					buffer.append(" ");//$NON-NLS-1$
+				}
+				if (!node.superInterfaceTypes().isEmpty()) {
+					buffer.append(node.isInterface() ? "extends " : "implements ");//$NON-NLS-2$//$NON-NLS-1$
+					for (Iterator it = node.superInterfaceTypes().iterator(); it.hasNext();) {
+						Type t = (Type) it.next();
+						t.accept(this);
+						if (it.hasNext()) {
+							buffer.append(", ");//$NON-NLS-1$
+						}
+					}
+					buffer.append(" ");//$NON-NLS-1$
+				}
+			}
+			buffer.append("{\n");//$NON-NLS-1$
+			indent++;
+			for (Iterator it = node.bodyDeclarations().iterator(); it.hasNext();) {
+				BodyDeclaration d = (BodyDeclaration) it.next();
+				d.accept(this);
+			}
+			indent--;
+			printIndent();
+			buffer.append("}\n");//$NON-NLS-1$
+			return false;
+		}
+
+		@Override
+		public boolean visit(TypeDeclarationStatement node) {
+			if (node.getAST().apiLevel() == JLS2) {
+				getTypeDeclaration(node).accept(this);
+			}
+			if (node.getAST().apiLevel() >= JLS3) {
+				node.getDeclaration().accept(this);
+			}
+			return false;
+		}
+
+		@Override
+		public boolean visit(TypeLiteral node) {
+			node.getType().accept(this);
+			buffer.append(".class");//$NON-NLS-1$
+			return false;
+		}
+
+		/*
+		 * @see ASTVisitor#visit(TypeMethodReference)
+		 *
+		 * @since 3.10
+		 */
+		@Override
+		public boolean visit(TypeMethodReference node) {
+			node.getType().accept(this);
+			visitReferenceTypeArguments(node.typeArguments());
+			node.getName().accept(this);
+			return false;
+		}
+
+		@Override
+		public boolean visit(TypeParameter node) {
+			if (node.getAST().apiLevel() >= JLS8) {
+				printModifiers(node.modifiers());
+			}
+			node.getName().accept(this);
+			if (!node.typeBounds().isEmpty()) {
+				buffer.append(" extends ");//$NON-NLS-1$
+				for (Iterator it = node.typeBounds().iterator(); it.hasNext();) {
+					Type t = (Type) it.next();
+					t.accept(this);
+					if (it.hasNext()) {
+						buffer.append(" & ");//$NON-NLS-1$
+					}
+				}
+			}
+			return false;
+		}
+
+		@Override
+		public boolean visit(UnionType node) {
+			for (Iterator it = node.types().iterator(); it.hasNext();) {
+				Type t = (Type) it.next();
+				t.accept(this);
+				if (it.hasNext()) {
+					buffer.append('|');
+				}
+			}
+			return false;
+		}
+
+		@Override
+		public boolean visit(UsesDirective node) {
+			printIndent();
+			buffer.append("uses");//$NON-NLS-1$
+			buffer.append(" ");//$NON-NLS-1$
+			node.getName().accept(this);
+			buffer.append(";\n");//$NON-NLS-1$
+			return false;
+		}
+
+		@Override
+		public boolean visit(VariableDeclarationExpression node) {
+			if (node.getAST().apiLevel() == JLS2) {
+				printModifiers(node.getModifiers());
+			}
+			if (node.getAST().apiLevel() >= JLS3) {
+				printModifiers(node.modifiers());
+			}
+			node.getType().accept(this);
+			buffer.append(" ");//$NON-NLS-1$
+			for (Iterator it = node.fragments().iterator(); it.hasNext();) {
+				VariableDeclarationFragment f = (VariableDeclarationFragment) it.next();
+				f.accept(this);
+				if (it.hasNext()) {
+					buffer.append(", ");//$NON-NLS-1$
+				}
+			}
+			return false;
+		}
+
+		@Override
+		public boolean visit(VariableDeclarationFragment node) {
+			addLocalBinding(node.resolveBinding(), node.getName().getIdentifier());
+
+			buffer.append(node.getName().getIdentifier());
+			int size = node.getExtraDimensions();
+			if (node.getAST().apiLevel() >= JLS8) {
+				List dimensions = node.extraDimensions();
+				for (int i = 0; i < size; i++) {
+					visit((Dimension) dimensions.get(i));
+				}
+			} else {
+				for (int i = 0; i < size; i++) {
+					buffer.append("[]");//$NON-NLS-1$
+				}
+			}
+			if (node.getInitializer() != null) {
+				buffer.append("=");//$NON-NLS-1$
+				node.getInitializer().accept(this);
+			}
+			return false;
+		}
+
+		@Override
+		public boolean visit(VariableDeclarationStatement node) {
+			printIndent();
+			if (node.getAST().apiLevel() == JLS2) {
+				printModifiers(node.getModifiers());
+			}
+			if (node.getAST().apiLevel() >= JLS3) {
+				printModifiers(node.modifiers());
+			}
+			node.getType().accept(this);
+			buffer.append(" ");//$NON-NLS-1$
+			for (Iterator it = node.fragments().iterator(); it.hasNext();) {
+				VariableDeclarationFragment f = (VariableDeclarationFragment) it.next();
+				f.accept(this);
+				if (it.hasNext()) {
+					buffer.append(", ");//$NON-NLS-1$
+				}
+			}
+			buffer.append(";\n");//$NON-NLS-1$
+			return false;
+		}
+
+		@Override
+		public boolean visit(WhileStatement node) {
+			printIndent();
+			buffer.append("while (");//$NON-NLS-1$
+			node.getExpression().accept(this);
+			buffer.append(") ");//$NON-NLS-1$
+			node.getBody().accept(this);
+			return false;
+		}
+
+		@Override
+		public boolean visit(WildcardType node) {
+			visitTypeAnnotations(node);
+			buffer.append("?");//$NON-NLS-1$
+			Type bound = node.getBound();
+			if (bound != null) {
+				if (node.isUpperBound()) {
+					buffer.append(" extends ");//$NON-NLS-1$
+				} else {
+					buffer.append(" super ");//$NON-NLS-1$
+				}
+				bound.accept(this);
+			}
+			return false;
+		}
+
+		@Override
+		public boolean visit(YieldStatement node) {
+			if ((node.getAST().isPreviewEnabled()) && node.isImplicit() && node.getExpression() == null) {
+				return false;
+			}
+			printIndent();
+			buffer.append("yield"); //$NON-NLS-1$
+			if (node.getExpression() != null) {
+				buffer.append(" ");//$NON-NLS-1$
+				node.getExpression().accept(this);
+			}
+			buffer.append(";\n");//$NON-NLS-1$
+			return false;
+		}
+
+		/**
+		 * @deprecated
+		 */
+		@Deprecated
+		private void visitComponentType(ArrayType node) {
+			node.getComponentType().accept(this);
+		}
+	}
+
+}
diff --git a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/ASTEvaluationEngine.java b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/ASTEvaluationEngine.java
index c54ca84..617191f 100644
--- a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/ASTEvaluationEngine.java
+++ b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/ASTEvaluationEngine.java
@@ -345,8 +345,7 @@
 				}
 			}
 			// Adding outer class variables to inner class scope
-			for (int i = 0; i < innerClassFields.length; i++) {
-				IVariable var = innerClassFields[i];
+			for (IVariable var : innerClassFields) {
 				if (var instanceof IJavaVariable && var.getName().startsWith(ANONYMOUS_VAR_PREFIX)) {
 					String name = var.getName().substring(ANONYMOUS_VAR_PREFIX.length());
 					if (!names.contains(name)) {
@@ -629,7 +628,7 @@
 		}
 
 		ASTInstructionCompiler visitor = new ASTInstructionCompiler(
-				mapper.getSnippetStart(), snippet);
+				mapper.getSnippetStart(), snippet, getJavaProject());
 		unit.accept(visitor);
 
 		return visitor.getInstructions();
diff --git a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/ASTInstructionCompiler.java b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/ASTInstructionCompiler.java
index 6941a01..762a4dd 100644
--- a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/ASTInstructionCompiler.java
+++ b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/ASTInstructionCompiler.java
@@ -26,11 +26,17 @@
 
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.core.runtime.Status;
+import org.eclipse.debug.core.DebugException;
 import org.eclipse.jdt.core.Flags;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.JavaModelException;
 import org.eclipse.jdt.core.Signature;
 import org.eclipse.jdt.core.compiler.IProblem;
 import org.eclipse.jdt.core.dom.*;
 import org.eclipse.jdt.internal.debug.core.JDIDebugPlugin;
+import org.eclipse.jdt.internal.debug.eval.ExpressionBinder;
+import org.eclipse.jdt.internal.debug.eval.RemoteEvaluator;
+import org.eclipse.jdt.internal.debug.eval.RemoteEvaluatorBuilder;
 import org.eclipse.jdt.internal.debug.eval.ast.instructions.AndAssignmentOperator;
 import org.eclipse.jdt.internal.debug.eval.ast.instructions.AndOperator;
 import org.eclipse.jdt.internal.debug.eval.ast.instructions.ArrayAllocation;
@@ -90,6 +96,7 @@
 import org.eclipse.jdt.internal.debug.eval.ast.instructions.PushType;
 import org.eclipse.jdt.internal.debug.eval.ast.instructions.RemainderAssignmentOperator;
 import org.eclipse.jdt.internal.debug.eval.ast.instructions.RemainderOperator;
+import org.eclipse.jdt.internal.debug.eval.ast.instructions.RemoteOperator;
 import org.eclipse.jdt.internal.debug.eval.ast.instructions.ReturnInstruction;
 import org.eclipse.jdt.internal.debug.eval.ast.instructions.RightShiftAssignmentOperator;
 import org.eclipse.jdt.internal.debug.eval.ast.instructions.RightShiftOperator;
@@ -156,14 +163,17 @@
 	// internal index used to create unique variable name
 	private int fUniqueIdIndex = 0;
 
+	private IJavaProject fJavaProject;
+
 	/**
 	 * Create a new AST instruction compiler
 	 */
-	public ASTInstructionCompiler(int startPosition, String snippet) {
+	public ASTInstructionCompiler(int startPosition, String snippet, IJavaProject javaProject) {
 		fStartPosition = startPosition;
 		fInstructions = new InstructionSequence(snippet);
 		fStack = new Stack<>();
 		fCompleteInstructions = new ArrayList<>();
+		fJavaProject = javaProject;
 	}
 
 	/**
@@ -226,6 +236,7 @@
 				((CompoundInstruction) instruction).setEnd(fCounter);
 			}
 			fInstructions.add(instruction);
+			//System.out.println("Added: " + instruction.toString()); //$NON-NLS-1$
 			verbose("Add " + instruction.toString()); //$NON-NLS-1$
 		}
 	}
@@ -2154,8 +2165,16 @@
 		if (!isActive()) {
 			return true;
 		}
-		setHasError(true);
-		addErrorMessage(EvaluationEngineMessages.ASTInstructionCompiler_Reference_expressions_cannot_be_used_in_an_evaluation_expression);
+		try {
+			RemoteEvaluatorBuilder builder = makeBuilder(node);
+			builder.acceptMethodReference(node, node.resolveTypeBinding());
+			RemoteEvaluator remoteEvaluator = builder.build();
+			push(new RemoteOperator(builder.getSnippet(), node.getStartPosition(), remoteEvaluator));
+			storeInstruction();
+		} catch (JavaModelException | DebugException e) {
+			addErrorMessage(e.getMessage());
+			setHasError(true);
+		}
 		return false;
 	}
 
@@ -2354,8 +2373,62 @@
 		if (!isActive()) {
 			return true;
 		}
-		setHasError(true);
-		addErrorMessage(EvaluationEngineMessages.ASTInstructionCompiler_Reference_expressions_cannot_be_used_in_an_evaluation_expression);
+
+		try {
+			RemoteEvaluatorBuilder builder = makeBuilder(node);
+			builder.acceptMethodReference(node, node.resolveTypeBinding());
+			RemoteEvaluator remoteEvaluator = builder.build();
+			push(new RemoteOperator(builder.getSnippet(), node.getStartPosition(), remoteEvaluator));
+			storeInstruction();
+		} catch (JavaModelException | DebugException e) {
+			addErrorMessage(e.getMessage());
+			setHasError(true);
+		}
+
+		return false;
+	}
+
+	private RemoteEvaluatorBuilder makeBuilder(ASTNode node) throws DebugException {
+		RemoteEvaluatorBuilder builder = new RemoteEvaluatorBuilder(fJavaProject, new ExpressionBinder() {
+			@Override
+			public void bind(IVariableBinding variableBinding, String asVariableName) {
+				String variableId = variableBinding.getName();
+				push(new PushLocalVariable(variableId));
+				storeInstruction();
+			}
+
+			@Override
+			public void bindThis(ITypeBinding typeBinding, String asVariableName) {
+				push(new PushThis(getEnclosingLevel(node, typeBinding)));
+				storeInstruction();
+			}
+
+		}, getEnclosingClass(node), isStaticContext(node), false);
+		return builder;
+	}
+
+	private ITypeBinding getEnclosingClass(ASTNode node) {
+		while (node != null) {
+			if (node instanceof MethodDeclaration) {
+				return ((MethodDeclaration) node).resolveBinding().getDeclaringClass();
+			}
+			if (node instanceof TypeDeclaration) {
+				return ((TypeDeclaration) node).resolveBinding();
+			}
+			node = node.getParent();
+		}
+		return null;
+	}
+
+	private boolean isStaticContext(ASTNode node) {
+		while (node != null) {
+			if (node instanceof MethodDeclaration) {
+				return Modifier.isStatic(((MethodDeclaration) node).getModifiers());
+			} else if (node instanceof Initializer) {
+				return Modifier.isStatic(((Initializer) node).getModifiers());
+			}
+			node = node.getParent();
+		}
 		return false;
 	}
 
@@ -2865,10 +2938,20 @@
 		if (!isActive()) {
 			return true;
 		}
-		setHasError(true);
-		addErrorMessage(EvaluationEngineMessages.ASTInstructionCompiler_Lambda_expressions_cannot_be_used_in_an_evaluation_expression);
+
+		try {
+			RemoteEvaluatorBuilder builder = makeBuilder(node);
+			builder.acceptLambda(node, node.resolveTypeBinding());
+			RemoteEvaluator remoteEvaluator = builder.build();
+			push(new RemoteOperator(builder.getSnippet(), node.getStartPosition(), remoteEvaluator));
+			storeInstruction();
+		} catch (JavaModelException | DebugException e) {
+			addErrorMessage(e.getMessage());
+			setHasError(true);
+		}
 		return false;
 	}
+
 	/*
 	 * (non-Javadoc)
 	 *
@@ -4064,17 +4147,15 @@
 			storeInstruction(); // jump
 		}
 
-		for (Iterator<slot> iter = jumpsStatements.iterator(); iter.hasNext();) {
-			currentslot = iter.next();
-			for (Iterator<ConditionalJump> iterator = currentslot.jumps.iterator(); iterator.hasNext();) {
-				ConditionalJump condJump = iterator.next();
+		for (slot slot : jumpsStatements) {
+			for (ConditionalJump condJump : slot.jumps) {
 				condJump.setOffset((fCounter - fInstructions.indexOf(condJump)) - 1);
 			}
 			if (currentslot.stmts != null) {
 				push(new Pop(0));
 				storeInstruction(); // pop
-				for (Iterator<Statement> iterator = currentslot.stmts.iterator(); iterator.hasNext();) {
-					iterator.next().accept(this);
+				for (Statement statement : currentslot.stmts) {
+					statement.accept(this);
 				}
 			}
 		}
@@ -4084,8 +4165,8 @@
 			jumpDefault.setOffset((fCounter - fInstructions.indexOf(jumpDefault)) - 1);
 			push(new Pop(0));
 			storeInstruction(); // pop
-			for (Iterator<Statement> iterator = statementsDefault.iterator(); iterator.hasNext();) {
-				iterator.next().accept(this);
+			for (Statement statement : statementsDefault) {
+				statement.accept(this);
 			}
 		} else if(jumpEnd != null){
 			jumpEnd.setOffset((fCounter - fInstructions.indexOf(jumpEnd)) - 1);
@@ -4251,8 +4332,18 @@
 		if (!isActive()) {
 			return true;
 		}
-		setHasError(true);
-		addErrorMessage(EvaluationEngineMessages.ASTInstructionCompiler_Reference_expressions_cannot_be_used_in_an_evaluation_expression);
+
+		try {
+			RemoteEvaluatorBuilder builder = makeBuilder(node);
+			builder.acceptMethodReference(node, node.resolveTypeBinding());
+			RemoteEvaluator remoteEvaluator = builder.build();
+			push(new RemoteOperator(builder.getSnippet(), node.getStartPosition(), remoteEvaluator));
+			storeInstruction();
+		} catch (JavaModelException | DebugException e) {
+			addErrorMessage(e.getMessage());
+			setHasError(true);
+		}
+
 		return false;
 	}
 
diff --git a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/BinaryBasedSourceGenerator.java b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/BinaryBasedSourceGenerator.java
index 2a17e34..a91e07d 100644
--- a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/BinaryBasedSourceGenerator.java
+++ b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/BinaryBasedSourceGenerator.java
@@ -152,9 +152,7 @@
 
 		Field thisField = null;
 
-		List<Field> fields = referenceType.visibleFields();
-		for (Iterator<Field> iterator = fields.iterator(); iterator.hasNext();) {
-			Field field = iterator.next();
+		for (Field field : referenceType.visibleFields()) {
 			if (field.name().startsWith("this$")) { //$NON-NLS-1$
 				thisField = field;
 				break;
@@ -330,39 +328,33 @@
 			source.append(buffer);
 		}
 
-		List<Field> fields = referenceType.fields();
-		for (Iterator<Field> iterator = fields.iterator(); iterator.hasNext();) {
-			Field field = iterator.next();
+		for (Field field : referenceType.fields()) {
 			if (!field.name().startsWith("this$")) { //$NON-NLS-1$
 				source.append(buildFieldDeclaration(field));
 			}
 		}
 
-		List<Method> methods = referenceType.methods();
-		for (Iterator<Method> iterator = methods.iterator(); iterator.hasNext();) {
-			Method method = iterator.next();
+		for (Method method : referenceType.methods()) {
 			if (!method.isConstructor() && !method.isStaticInitializer()
-					&& !method.isBridge()) {
+				&& !method.isBridge()) {
 				source.append(buildMethodDeclaration(method));
 			}
 		}
 
 		List<ReferenceType> nestedTypes = referenceType.nestedTypes();
 		if (nestedTypeName == null) {
-			for (Iterator<ReferenceType> iterator = nestedTypes.iterator(); iterator.hasNext();) {
-				ReferenceType nestedType = iterator.next();
+			for (ReferenceType nestedType : nestedTypes) {
 				if (isADirectInnerType(typeName, nestedType.name())) {
 					source.append(buildTypeDeclaration(nestedType, null, null,
-							true));
+						true));
 				}
 			}
 		} else {
-			for (Iterator<ReferenceType> iterator = nestedTypes.iterator(); iterator.hasNext();) {
-				ReferenceType nestedType = iterator.next();
+			for (ReferenceType nestedType : nestedTypes) {
 				if (!nestedTypeName.equals(nestedType.name())
-						&& isADirectInnerType(typeName, nestedType.name())) {
+					&& isADirectInnerType(typeName, nestedType.name())) {
 					source.append(buildTypeDeclaration(nestedType, null, null,
-							true));
+						true));
 				}
 			}
 		}
diff --git a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/EvaluationEngineMessages.java b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/EvaluationEngineMessages.java
index 42d9044..138371d 100644
--- a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/EvaluationEngineMessages.java
+++ b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/EvaluationEngineMessages.java
@@ -62,6 +62,7 @@
 	public static String ASTInstructionCompiler_Lambda_expressions_cannot_be_used_in_an_evaluation_expression;
 	public static String ASTInstructionCompiler_Reference_expressions_cannot_be_used_in_an_evaluation_expression;
 	public static String ASTInstructionCompiler_Switch_expressions_cannot_be_used_in_an_evaluation_expression;
+	public static String ASTInstructionCompiler_Functional_expressions_cannot_be_evaluated_inside_local_and_or_anonymous_classes;
 
 	static {
 		// load message values from bundle file
diff --git a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/EvaluationEngineMessages.properties b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/EvaluationEngineMessages.properties
index 5f19282..125c9ce 100644
--- a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/EvaluationEngineMessages.properties
+++ b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/EvaluationEngineMessages.properties
@@ -57,4 +57,5 @@
 
 ASTInstructionCompiler_Lambda_expressions_cannot_be_used_in_an_evaluation_expression=Lambda expressions cannot be used in an evaluation expression
 ASTInstructionCompiler_Reference_expressions_cannot_be_used_in_an_evaluation_expression=Reference expressions cannot be used in an evaluation expression
-ASTInstructionCompiler_Switch_expressions_cannot_be_used_in_an_evaluation_expression=Switch expressions cannot be used in an evaluation expression
\ No newline at end of file
+ASTInstructionCompiler_Switch_expressions_cannot_be_used_in_an_evaluation_expression=Switch expressions cannot be used in an evaluation expression
+ASTInstructionCompiler_Functional_expressions_cannot_be_evaluated_inside_local_and_or_anonymous_classes=Functional expressions cannot be evaluated inside local and or anonymous classes
\ No newline at end of file
diff --git a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/EvaluationSourceGenerator.java b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/EvaluationSourceGenerator.java
index 0685c85..3146f70 100644
--- a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/EvaluationSourceGenerator.java
+++ b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/EvaluationSourceGenerator.java
@@ -14,7 +14,6 @@
  *******************************************************************************/
 package org.eclipse.jdt.internal.debug.eval.ast.engine;
 
-import java.util.Iterator;
 import java.util.Map;
 
 import org.eclipse.core.runtime.CoreException;
@@ -315,8 +314,7 @@
 	 */
 	public static Map<String, String> getCompilerOptions(IJavaProject project) {
 		Map<String, String> options = project.getOptions(true);
-		for (Iterator<String> iter = options.keySet().iterator(); iter.hasNext();) {
-			String key = iter.next();
+		for (String key : options.keySet()) {
 			String value = options.get(key);
 			if (JavaCore.ERROR.equals(value) || JavaCore.WARNING.equals(value) || JavaCore.INFO.equals(value)) {
 				options.put(key, JavaCore.IGNORE);
diff --git a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/Interpreter.java b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/Interpreter.java
index d9d1460..51377b8 100644
--- a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/Interpreter.java
+++ b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/Interpreter.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2011 IBM Corporation and others.
+ * Copyright (c) 2000, 2020 IBM Corporation and others.
  *
  * This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
@@ -121,6 +121,10 @@
 			value.disableCollection();
 			fPermStorage.add(value);
 		} catch (CoreException e) {
+			// don't worry about GC if the VM has terminated
+			if ((e.getStatus().getException() instanceof VMDisconnectedException)) {
+				return;
+			}
 			JDIDebugPlugin.log(e);
 		}
 	}
diff --git a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/SourceBasedSourceGenerator.java b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/SourceBasedSourceGenerator.java
index cffaf52..4b89662 100644
--- a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/SourceBasedSourceGenerator.java
+++ b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/SourceBasedSourceGenerator.java
@@ -427,8 +427,7 @@
 			fSnippetStartPosition += source.length();
 			source.append(buffer.toString());
 		}
-		for (Iterator<BodyDeclaration> iterator = list.iterator(); iterator.hasNext();) {
-			BodyDeclaration bodyDeclaration = iterator.next();
+		for (BodyDeclaration bodyDeclaration : list) {
 			if (bodyDeclaration instanceof FieldDeclaration) {
 				source.append(buildFieldDeclaration((FieldDeclaration) bodyDeclaration));
 			} else if (bodyDeclaration instanceof MethodDeclaration) {
diff --git a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/instructions/InstructionSequence.java b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/instructions/InstructionSequence.java
index a80f7a0..3de2379 100644
--- a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/instructions/InstructionSequence.java
+++ b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/instructions/InstructionSequence.java
@@ -14,7 +14,6 @@
 package org.eclipse.jdt.internal.debug.eval.ast.instructions;
 
 import java.util.ArrayList;
-import java.util.Iterator;
 import java.util.List;
 
 import org.eclipse.core.runtime.CoreException;
@@ -79,8 +78,8 @@
 	public Message[] getErrors() {
 		Message[] messages = new Message[fErrors.size()];
 		int i = 0;
-		for (Iterator<String> iter = fErrors.iterator(); iter.hasNext();) {
-			messages[i++] = new Message(iter.next(), -1);
+		for (String errorMsg : fErrors) {
+			messages[i++] = new Message(errorMsg, -1);
 		}
 		return messages;
 	}
diff --git a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/instructions/InstructionsEvaluationMessages.java b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/instructions/InstructionsEvaluationMessages.java
index b97de5f..9d92c16 100644
--- a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/instructions/InstructionsEvaluationMessages.java
+++ b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/instructions/InstructionsEvaluationMessages.java
@@ -29,6 +29,7 @@
 	public static String AssignmentOperator_operator_1;
 	public static String Cast_ClassCastException__Cannot_cast__0__as__1___1;
 	public static String Cast_cast_3;
+	public static String Run_Remote_1;
 	public static String ConditionalJump_conditional_jump_1;
 	public static String Constructor_constructor__1;
 	public static String LocalVariableCreation_create_local_variable__0___1___1;
diff --git a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/instructions/InstructionsEvaluationMessages.properties b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/instructions/InstructionsEvaluationMessages.properties
index ed26ba7..15f1260 100644
--- a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/instructions/InstructionsEvaluationMessages.properties
+++ b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/instructions/InstructionsEvaluationMessages.properties
@@ -24,6 +24,7 @@
 Cast_cast_3=cast
 ConditionalJump_conditional_jump_1=conditional jump
 Constructor_constructor__1=constructor
+Run_Remote_1=run remote code
 LocalVariableCreation_create_local_variable__0___1___1=Create local variable {1} {0}
 DivideAssignmentOperator_operator_1='/=\' operator
 DivideOperator_Divide_by_zero_1=Divide by zero
diff --git a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/instructions/RemoteOperator.java b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/instructions/RemoteOperator.java
new file mode 100644
index 0000000..c47f065
--- /dev/null
+++ b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/instructions/RemoteOperator.java
@@ -0,0 +1,53 @@
+/*******************************************************************************
+ * Copyright (c) 2020, Jesper Steen Møller and others.
+ *
+ * This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *     Jesper Steen Møller - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jdt.internal.debug.eval.ast.instructions;
+
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.jdt.debug.core.IJavaValue;
+import org.eclipse.jdt.internal.debug.eval.RemoteEvaluator;
+
+/**
+ * Invokes a method on a object in a class injected into the debug target. The arguments are on the stack in reverse order, followed by the type.
+ * Pushes the result onto the stack
+ */
+public class RemoteOperator extends CompoundInstruction {
+
+	private RemoteEvaluator fEvaluator;
+	private String fSignature;
+
+	public RemoteOperator(String body, int start, RemoteEvaluator evaluator) {
+		super(start);
+		fSignature = body;
+		fEvaluator = evaluator;
+	}
+
+	@Override
+	public void execute() throws CoreException {
+		int variableCount = fEvaluator.getVariableCount();
+		IJavaValue[] args = new IJavaValue[variableCount];
+		// args are in reverse order
+		for (int i = variableCount - 1; i >= 0; i--) {
+			args[i] = popValue();
+		}
+		IJavaValue result = fEvaluator.evaluate(this.getContext().getThread(), args);
+		push(result);
+	}
+
+	@Override
+	public String toString() {
+		return InstructionsEvaluationMessages.Run_Remote_1
+				+ fSignature;
+	}
+
+}
diff --git a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/instructions/RuntimeSignature.java b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/instructions/RuntimeSignature.java
index 02e5833..59d1493 100644
--- a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/instructions/RuntimeSignature.java
+++ b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/instructions/RuntimeSignature.java
@@ -247,8 +247,8 @@
 
 			// parameter names
 			if(parameterNames != null) {
-				for (int i = 0; i < parameterNames.length; i++) {
-					resultLength += parameterNames[i].length + 1;
+				for (char[] parameterName : parameterNames) {
+					resultLength += parameterName.length + 1;
 					// parameter name + space
 				}
 			}
diff --git a/org.eclipse.jdt.debug/jdi/org/eclipse/jdi/internal/MethodImpl.java b/org.eclipse.jdt.debug/jdi/org/eclipse/jdi/internal/MethodImpl.java
index 90ead5b..835cb9e 100644
--- a/org.eclipse.jdt.debug/jdi/org/eclipse/jdi/internal/MethodImpl.java
+++ b/org.eclipse.jdt.debug/jdi/org/eclipse/jdi/internal/MethodImpl.java
@@ -274,8 +274,9 @@
 		Iterator<LocalVariable> iter = variables().iterator();
 		while (iter.hasNext()) {
 			LocalVariable var = iter.next();
-			if (var.isArgument())
+			if (var.isArgument()) {
 				result.add(var);
+			}
 		}
 		fArguments = result;
 		return fArguments;
@@ -290,10 +291,9 @@
 		if (fArgumentTypeNames != null) {
 			return fArgumentTypeNames;
 		}
-		List<String> argumentTypeSignatures = argumentTypeSignatures();
 		List<String> result = new ArrayList<>();
-		for (Iterator<String> iter = argumentTypeSignatures.iterator(); iter.hasNext();) {
-			result.add(TypeImpl.signatureToName(iter.next()));
+		for (String signature : argumentTypeSignatures()) {
+			result.add(TypeImpl.signatureToName(signature));
 		}
 
 		fArgumentTypeNames = result;
@@ -394,15 +394,17 @@
 	 */
 	@Override
 	public int compareTo(Method method) {
-		if (method == null || !method.getClass().equals(this.getClass()))
+		if (method == null || !method.getClass().equals(this.getClass())) {
 			throw new ClassCastException(
 					JDIMessages.MethodImpl_Can__t_compare_method_to_given_object_6);
+		}
 
 		// See if declaring types are the same, if not return comparison between
 		// declaring types.
 		Method type2 = method;
-		if (!declaringType().equals(type2.declaringType()))
+		if (!declaringType().equals(type2.declaringType())) {
 			return declaringType().compareTo(type2.declaringType());
+		}
 
 		// Return comparison of position within declaring type.
 		int index1 = declaringType().methods().indexOf(this);
@@ -699,8 +701,9 @@
 		// See Location.
 		ReferenceTypeImpl referenceType = ReferenceTypeImpl.readWithTypeTag(
 				target, in);
-		if (referenceType == null)
+		if (referenceType == null) {
 			return null;
+		}
 
 		JdwpMethodID ID = new JdwpMethodID(vmImpl);
 		if (target.fVerboseWriter != null) {
@@ -877,16 +880,15 @@
 	 */
 	protected List<Location> javaStratumLocationsOfLines(List<Integer> javaLines)	throws AbsentInformationException {
 		Set<Long> tmpLocations = new TreeSet<>();
-		for (Iterator<Integer> iter = javaLines.iterator(); iter.hasNext();) {
-			Integer key = iter.next();
+		for (Integer key : javaLines) {
 			List<Long> indexes = javaStratumLineToCodeIndexes(key.intValue());
 			if (indexes != null) {
 				tmpLocations.addAll(indexes);
 			}
 		}
 		List<Location> locations = new ArrayList<>();
-		for (Iterator<Long> iter = tmpLocations.iterator(); iter.hasNext();) {
-			long index = iter.next().longValue();
+		for (Long location : tmpLocations) {
+			long index = location.longValue();
 			int position = Arrays.binarySearch(fCodeIndexTable, index);
 			if(position < 0) {
 				//https://bugs.eclipse.org/bugs/show_bug.cgi?id=388172
diff --git a/org.eclipse.jdt.debug/jdi/org/eclipse/jdi/internal/ReferenceTypeImpl.java b/org.eclipse.jdt.debug/jdi/org/eclipse/jdi/internal/ReferenceTypeImpl.java
index 77ac963..7d2b1ee 100644
--- a/org.eclipse.jdt.debug/jdi/org/eclipse/jdi/internal/ReferenceTypeImpl.java
+++ b/org.eclipse.jdt.debug/jdi/org/eclipse/jdi/internal/ReferenceTypeImpl.java
@@ -158,8 +158,7 @@
 			List<Integer> list = new ArrayList<>();
 			List<int[]> outputLines = fLineInfo.get(new Integer(lineNumber));
 			if (outputLines != null) {
-				for (Iterator<int[]> iter = outputLines.iterator(); iter.hasNext();) {
-					int[] info = iter.next();
+				for (int[] info : outputLines) {
 					int outputLineNumber = info[0];
 					int length = info[1];
 					if (length == 0) {
@@ -282,8 +281,7 @@
 				throws AbsentInformationException {
 			FileInfo fileInfo = null;
 			// get the FileInfo object
-			for (Iterator<FileInfo> iter = fFileInfos.iterator(); iter.hasNext();) {
-				FileInfo element = iter.next();
+			for (FileInfo element : fFileInfos) {
 				if (element.fFileId == lineFileId) {
 					fileInfo = element;
 				}
@@ -333,8 +331,7 @@
 		 *            the source name to search.
 		 */
 		public FileInfo getFileInfo(String sourceName) {
-			for (Iterator<FileInfo> iter = fFileInfos.iterator(); iter.hasNext();) {
-				FileInfo fileInfo = iter.next();
+			for (FileInfo fileInfo : fFileInfos) {
 				if (fileInfo.fFileName.equals(sourceName)) {
 					return fileInfo;
 				}
@@ -583,8 +580,8 @@
 		List<Method> visibleMethods = new ArrayList<>();
 
 		// The methods of its own (own methods() command).
-		for (Iterator<Method> iter = methods().iterator(); iter.hasNext();) {
-			MethodImpl method = (MethodImpl) iter.next();
+		for (Method m : methods()) {
+			MethodImpl method = (MethodImpl) m;
 			namesAndSignatures.add(method.name() + method.signature());
 			visibleMethods.add(method);
 		}
@@ -1542,8 +1539,8 @@
 				throw new AbsentInformationException(
 						JDIMessages.ReferenceTypeImpl_30);
 			}
-			for (Iterator<FileInfo> iter = stratum.fFileInfos.iterator(); iter.hasNext();) {
-				list.add(iter.next().fFileName);
+			for (FileInfo fileInfo : stratum.fFileInfos) {
+				list.add(fileInfo.fFileName);
 			}
 			return list;
 		}
@@ -1564,8 +1561,7 @@
 		Stratum stratum = getStratum(stratumId);
 		if (stratum != null) {
 			// return the source paths defined for this stratum in the SMAP.
-			for (Iterator<FileInfo> iter = stratum.fFileInfos.iterator(); iter.hasNext();) {
-				FileInfo fileInfo = iter.next();
+			for (FileInfo fileInfo : stratum.fFileInfos) {
 				String path = fileInfo.fAbsoluteFileName;
 				if (path == null) {
 					path = getPath(fileInfo.fFileName);
@@ -1906,8 +1902,7 @@
 				fileId = lineInfos.get(0)[0];
 			}
 		}
-		for (Iterator<FileInfo> iter = stratum.fFileInfos.iterator(); iter.hasNext();) {
-			FileInfo fileInfo = iter.next();
+		for (FileInfo fileInfo : stratum.fFileInfos) {
 			if (fileInfo.fFileId == fileId) {
 				return fileInfo;
 			}
@@ -2088,8 +2083,7 @@
 				for (int i = 0, length = javaStratumLineNumberTable.length; i < length; i++) {
 					List<int[]> lineInfos = stratum.getInputLineInfos(javaStratumLineNumberTable[i]);
 					if (lineInfos != null) {
-						for (Iterator<int[]> iter = lineInfos.iterator(); iter.hasNext();) {
-							int[] lineInfo = iter.next();
+						for (int[] lineInfo : lineInfos) {
 							if (lineInfo[0] == fileId) {
 								if (!lineInfo.equals(lineInfoTable[lastIndex])) {
 									lineInfoTable[i] = lineInfo;
diff --git a/org.eclipse.jdt.debug/jdi/org/eclipse/jdi/internal/ValueImpl.java b/org.eclipse.jdt.debug/jdi/org/eclipse/jdi/internal/ValueImpl.java
index fc2137f..daadc80 100644
--- a/org.eclipse.jdt.debug/jdi/org/eclipse/jdi/internal/ValueImpl.java
+++ b/org.eclipse.jdt.debug/jdi/org/eclipse/jdi/internal/ValueImpl.java
@@ -140,8 +140,9 @@
 			throws IOException {
 		JdwpObjectID nullID = new JdwpObjectID(target.virtualMachineImpl());
 		nullID.write(out);
-		if (target.fVerboseWriter != null)
+		if (target.fVerboseWriter != null) {
 			target.fVerboseWriter.println("objectReference", nullID.value()); //$NON-NLS-1$
+		}
 	}
 
 	/**
@@ -269,9 +270,8 @@
 						return;
 					}
 				} else {
-					List<InterfaceType> interfaces = ((ClassType) valueType).allInterfaces();
-					for (Iterator<InterfaceType> iter = interfaces.iterator(); iter.hasNext();) {
-						if (checkInterfaceType(iter.next(),
+					for (InterfaceType interfaceType : ((ClassType) valueType).allInterfaces()) {
+						if (checkInterfaceType(interfaceType,
 								(InterfaceType) type)) {
 							return;
 						}
@@ -291,9 +291,8 @@
 		if (valueType.equals(type)) {
 			return true;
 		}
-		List<InterfaceType> superInterfaces = valueType.superinterfaces();
-		for (Iterator<InterfaceType> iter = superInterfaces.iterator(); iter.hasNext();) {
-			if (checkInterfaceType(iter.next(), type)) {
+		for (InterfaceType interfaceType : valueType.superinterfaces()) {
+			if (checkInterfaceType(interfaceType, type)) {
 				return true;
 			}
 		}
diff --git a/org.eclipse.jdt.debug/jdi/org/eclipse/jdi/internal/request/EventRequestImpl.java b/org.eclipse.jdt.debug/jdi/org/eclipse/jdi/internal/request/EventRequestImpl.java
index 20a606e..347c2fc 100644
--- a/org.eclipse.jdt.debug/jdi/org/eclipse/jdi/internal/request/EventRequestImpl.java
+++ b/org.eclipse.jdt.debug/jdi/org/eclipse/jdi/internal/request/EventRequestImpl.java
@@ -613,9 +613,7 @@
 		// communicating with SUN's VM.
 		// It seems to expect them 'the wrong way around'.
 		if (fThreadStepFilters != null) {
-			for (int i = 0; i < fThreadStepFilters.size(); i++) {
-				ThreadStepFilter filter = fThreadStepFilters
-						.get(i);
+			for (ThreadStepFilter filter : fThreadStepFilters) {
 				writeByte(MODIF_KIND_STEP,
 						"modifier", modifierKindMap(), outData); //$NON-NLS-1$
 				filter.fThread.write(this, outData);
@@ -626,17 +624,15 @@
 			}
 		}
 		if (fFieldFilters != null) {
-			for (int i = 0; i < fFieldFilters.size(); i++) {
+			for (FieldImpl field : fFieldFilters) {
 				writeByte(MODIF_KIND_FIELDONLY,
 						"modifier", modifierKindMap(), outData); //$NON-NLS-1$
-				fFieldFilters.get(i).writeWithReferenceType(this,
+				field.writeWithReferenceType(this,
 						outData);
 			}
 		}
 		if (fExceptionFilters != null) {
-			for (int i = 0; i < fExceptionFilters.size(); i++) {
-				ExceptionFilter filter = fExceptionFilters
-						.get(i);
+			for (ExceptionFilter filter : fExceptionFilters) {
 				writeByte(MODIF_KIND_EXCEPTIONONLY,
 						"modifier", modifierKindMap(), outData); //$NON-NLS-1$
 				if (filter.fException != null)
@@ -649,66 +645,66 @@
 			}
 		}
 		if (fLocationFilters != null) {
-			for (int i = 0; i < fLocationFilters.size(); i++) {
+			for (LocationImpl locationFilter : fLocationFilters) {
 				writeByte(MODIF_KIND_LOCATIONONLY,
 						"modifier", modifierKindMap(), outData); //$NON-NLS-1$
-				fLocationFilters.get(i).write(this, outData);
+				locationFilter.write(this, outData);
 			}
 		}
 		if (fClassExclusionFilters != null) {
-			for (int i = 0; i < fClassExclusionFilters.size(); i++) {
+			for (String classExclusionFilter : fClassExclusionFilters) {
 				writeByte(MODIF_KIND_CLASSEXCLUDE,
 						"modifier", modifierKindMap(), outData); //$NON-NLS-1$
-				writeString(fClassExclusionFilters.get(i),
+				writeString(classExclusionFilter,
 						"class excl. filter", outData); //$NON-NLS-1$
 			}
 		}
 		if (fClassFilters != null) {
-			for (int i = 0; i < fClassFilters.size(); i++) {
+			for (String classFilter : fClassFilters) {
 				writeByte(MODIF_KIND_CLASSMATCH,
 						"modifier", modifierKindMap(), outData); //$NON-NLS-1$
-				writeString(fClassFilters.get(i),
+				writeString(classFilter,
 						"class filter", outData); //$NON-NLS-1$
 			}
 		}
 		if (fClassFilterRefs != null) {
-			for (int i = 0; i < fClassFilterRefs.size(); i++) {
+			for (ReferenceType classFilterRef : fClassFilterRefs) {
 				writeByte(MODIF_KIND_CLASSONLY,
 						"modifier", modifierKindMap(), outData); //$NON-NLS-1$
-				((ReferenceTypeImpl) fClassFilterRefs.get(i)).write(this,
+				((ReferenceTypeImpl) classFilterRef).write(this,
 						outData);
 			}
 		}
 		if (fThreadFilters != null) {
-			for (int i = 0; i < fThreadFilters.size(); i++) {
+			for (ThreadReference threadFilter : fThreadFilters) {
 				writeByte(MODIF_KIND_THREADONLY,
 						"modifier", modifierKindMap(), outData); //$NON-NLS-1$
-				((ThreadReferenceImpl) fThreadFilters.get(i)).write(this,
+				((ThreadReferenceImpl) threadFilter).write(this,
 						outData);
 			}
 		}
 		if (fCountFilters != null) {
-			for (int i = 0; i < fCountFilters.size(); i++) {
+			for (Integer countFilter : fCountFilters) {
 				writeByte(MODIF_KIND_COUNT,
 						"modifier", modifierKindMap(), outData); //$NON-NLS-1$
-				writeInt(fCountFilters.get(i).intValue(),
+				writeInt(countFilter.intValue(),
 						"count filter", outData); //$NON-NLS-1$
 			}
 		}
 		if (fInstanceFilters != null) {
-			for (int i = 0; i < fInstanceFilters.size(); i++) {
+			for (ObjectReference instanceFilter : fInstanceFilters) {
 				writeByte(MODIF_KIND_INSTANCE,
 						"modifier", modifierKindMap(), outData); //$NON-NLS-1$
-				((ObjectReferenceImpl) fInstanceFilters.get(i)).write(this,
+				((ObjectReferenceImpl) instanceFilter).write(this,
 						outData);
 			}
 		}
 		if (fSourceNameFilters != null) {
 			if (supportsSourceNameFilters()) {
-				for (int i = 0; i < fSourceNameFilters.size(); i++) {
+				for (String sourceNameFilter : fSourceNameFilters) {
 					writeByte(MODIF_KIND_SOURCE_NAME_FILTER,
 							"modifier", modifierKindMap(), outData); //$NON-NLS-1$
-					writeString(fSourceNameFilters.get(i),
+					writeString(sourceNameFilter,
 							"modifier", outData); //$NON-NLS-1$
 				}
 			}
@@ -732,13 +728,11 @@
 		if (fStepSizeMap != null)
 			return;
 
-		java.lang.reflect.Field[] fields = EventRequestImpl.class
-				.getDeclaredFields();
 		fStepSizeMap = new HashMap<>();
 		fStepDepthMap = new HashMap<>();
 		fSuspendPolicyMap = new HashMap<>();
 		fModifierKindMap = new HashMap<>();
-		for (Field field : fields) {
+		for (Field field : EventRequestImpl.class.getDeclaredFields()) {
 			if ((field.getModifiers() & java.lang.reflect.Modifier.PUBLIC) == 0
 					|| (field.getModifiers() & java.lang.reflect.Modifier.STATIC) == 0
 					|| (field.getModifiers() & java.lang.reflect.Modifier.FINAL) == 0)
diff --git a/org.eclipse.jdt.debug/model/org/eclipse/jdt/debug/core/JDIDebugModel.java b/org.eclipse.jdt.debug/model/org/eclipse/jdt/debug/core/JDIDebugModel.java
index d60d947..97aadd6 100644
--- a/org.eclipse.jdt.debug/model/org/eclipse/jdt/debug/core/JDIDebugModel.java
+++ b/org.eclipse.jdt.debug/model/org/eclipse/jdt/debug/core/JDIDebugModel.java
@@ -847,15 +847,14 @@
 		String markerType = JavaLineBreakpoint.getMarkerType();
 		IBreakpointManager manager = DebugPlugin.getDefault()
 				.getBreakpointManager();
-		IBreakpoint[] breakpoints = manager.getBreakpoints(modelId);
-		for (int i = 0; i < breakpoints.length; i++) {
-			if (!(breakpoints[i] instanceof IJavaLineBreakpoint)) {
+		for (IBreakpoint bp : manager.getBreakpoints(modelId)) {
+			if (!(bp instanceof IJavaLineBreakpoint)) {
 				continue;
 			}
-			IJavaLineBreakpoint breakpoint = (IJavaLineBreakpoint) breakpoints[i];
+			IJavaLineBreakpoint breakpoint = (IJavaLineBreakpoint) bp;
 			IMarker marker = breakpoint.getMarker();
 			if (marker != null && marker.exists()
-					&& marker.getType().equals(markerType)) {
+				&& marker.getType().equals(markerType)) {
 				String breakpointTypeName = breakpoint.getTypeName();
 				if (JavaDebugUtils.typeNamesEqual(breakpointTypeName, typeName) || (breakpointTypeName != null && breakpointTypeName.startsWith(typeName + '$'))) {
 					if (breakpoint.getLineNumber() == lineNumber) {
@@ -893,19 +892,18 @@
 		String markerType = JavaLineBreakpoint.getMarkerType();
 		IBreakpointManager manager = DebugPlugin.getDefault()
 				.getBreakpointManager();
-		IBreakpoint[] breakpoints = manager.getBreakpoints(modelId);
-		for (int i = 0; i < breakpoints.length; i++) {
-			if (!(breakpoints[i] instanceof IJavaLineBreakpoint)) {
+		for (IBreakpoint bp : manager.getBreakpoints(modelId)) {
+			if (!(bp instanceof IJavaLineBreakpoint)) {
 				continue;
 			}
-			IJavaLineBreakpoint breakpoint = (IJavaLineBreakpoint) breakpoints[i];
+			IJavaLineBreakpoint breakpoint = (IJavaLineBreakpoint) bp;
 			IMarker marker = breakpoint.getMarker();
 			if (marker != null && marker.exists()
-					&& marker.getType().equals(markerType)) {
+				&& marker.getType().equals(markerType)) {
 				String breakpointTypeName = breakpoint.getTypeName();
 				if ((JavaDebugUtils.typeNamesEqual(breakpointTypeName, typeName) || (breakpointTypeName != null && breakpointTypeName.startsWith(typeName + '$')))
-						&& breakpoint.getLineNumber() == lineNumber
-						&& resource.equals(marker.getResource())) {
+					&& breakpoint.getLineNumber() == lineNumber
+					&& resource.equals(marker.getResource())) {
 					return breakpoint;
 				}
 			}
diff --git a/org.eclipse.jdt.debug/model/org/eclipse/jdt/internal/debug/core/breakpoints/JavaStratumLineBreakpoint.java b/org.eclipse.jdt.debug/model/org/eclipse/jdt/internal/debug/core/breakpoints/JavaStratumLineBreakpoint.java
index 729248d..d03882f 100644
--- a/org.eclipse.jdt.debug/model/org/eclipse/jdt/internal/debug/core/breakpoints/JavaStratumLineBreakpoint.java
+++ b/org.eclipse.jdt.debug/model/org/eclipse/jdt/internal/debug/core/breakpoints/JavaStratumLineBreakpoint.java
@@ -247,8 +247,8 @@
 	}
 
 	private boolean containsMatch(List<String> strings, String key) {
-		for (Iterator<String> iter = strings.iterator(); iter.hasNext();) {
-			if (iter.next().equals(key)) {
+		for (String string : strings) {
+			if (string.equals(key)) {
 				return true;
 			}
 		}
diff --git a/org.eclipse.jdt.debug/model/org/eclipse/jdt/internal/debug/core/logicalstructures/JavaLogicalStructures.java b/org.eclipse.jdt.debug/model/org/eclipse/jdt/internal/debug/core/logicalstructures/JavaLogicalStructures.java
index 6dc8765..5687af9 100644
--- a/org.eclipse.jdt.debug/model/org/eclipse/jdt/internal/debug/core/logicalstructures/JavaLogicalStructures.java
+++ b/org.eclipse.jdt.debug/model/org/eclipse/jdt/internal/debug/core/logicalstructures/JavaLogicalStructures.java
@@ -122,9 +122,8 @@
 	 */
 	private static void addAllLogicalStructures(
 			List<JavaLogicalStructure> pluginContributedJavaLogicalStructures) {
-		for (Iterator<JavaLogicalStructure> iter = pluginContributedJavaLogicalStructures.iterator(); iter
-				.hasNext();) {
-			addLogicalStructure(iter.next());
+		for (JavaLogicalStructure logicalStructure : pluginContributedJavaLogicalStructures) {
+			addLogicalStructure(logicalStructure);
 		}
 	}
 
@@ -208,17 +207,14 @@
 	 */
 	public static void saveUserDefinedJavaLogicalStructures() {
 		StringBuilder logicalStructuresString = new StringBuilder();
-		for (Iterator<JavaLogicalStructure> iter = fUserDefinedJavaLogicalStructures.iterator(); iter
-				.hasNext();) {
-			JavaLogicalStructure logicalStructure = iter
-					.next();
+		for (JavaLogicalStructure logicalStructure : fUserDefinedJavaLogicalStructures) {
 			logicalStructuresString.append(
-					logicalStructure.getQualifiedTypeName()).append('\0');
+				logicalStructure.getQualifiedTypeName()).append('\0');
 			logicalStructuresString.append(logicalStructure.getDescription())
-					.append('\0');
+				.append('\0');
 			logicalStructuresString.append(
-					logicalStructure.isSubtypes() ? IS_SUBTYPE_TRUE
-							: IS_SUBTYPE_FALSE).append('\0');
+				logicalStructure.isSubtypes() ? IS_SUBTYPE_TRUE
+					: IS_SUBTYPE_FALSE).append('\0');
 			String value = logicalStructure.getValue();
 			if (value != null) {
 				logicalStructuresString.append(value);
@@ -249,13 +245,11 @@
 		JavaLogicalStructure[] logicalStructures = new JavaLogicalStructure[fPluginContributedJavaLogicalStructures
 				.size() + fUserDefinedJavaLogicalStructures.size()];
 		int i = 0;
-		for (Iterator<JavaLogicalStructure> iter = fPluginContributedJavaLogicalStructures.iterator(); iter
-				.hasNext();) {
-			logicalStructures[i++] = iter.next();
+		for (JavaLogicalStructure logicalStructure : fPluginContributedJavaLogicalStructures) {
+			logicalStructures[i++] = logicalStructure;
 		}
-		for (Iterator<JavaLogicalStructure> iter = fUserDefinedJavaLogicalStructures.iterator(); iter
-				.hasNext();) {
-			logicalStructures[i++] = iter.next();
+		for (JavaLogicalStructure logicalStructure : fUserDefinedJavaLogicalStructures) {
+			logicalStructures[i++] = logicalStructure;
 		}
 		return logicalStructures;
 	}
diff --git a/org.eclipse.jdt.debug/model/org/eclipse/jdt/internal/debug/core/model/JDIObjectValue.java b/org.eclipse.jdt.debug/model/org/eclipse/jdt/internal/debug/core/model/JDIObjectValue.java
index 307c462..15b0b91 100644
--- a/org.eclipse.jdt.debug/model/org/eclipse/jdt/internal/debug/core/model/JDIObjectValue.java
+++ b/org.eclipse.jdt.debug/model/org/eclipse/jdt/internal/debug/core/model/JDIObjectValue.java
@@ -453,10 +453,9 @@
 	public IJavaThread[] getWaitingThreads() throws DebugException {
 		List<JDIThread> waiting = new ArrayList<>();
 		try {
-			List<ThreadReference> threads = getUnderlyingObject().waitingThreads();
 			JDIDebugTarget debugTarget = (JDIDebugTarget) getDebugTarget();
-			for (Iterator<ThreadReference> iter = threads.iterator(); iter.hasNext();) {
-				JDIThread jdiThread = debugTarget.findThread(iter.next());
+			for (ThreadReference threadReference : getUnderlyingObject().waitingThreads()) {
+				JDIThread jdiThread = debugTarget.findThread(threadReference);
 				if (jdiThread != null) {
 					waiting.add(jdiThread);
 				}
diff --git a/org.eclipse.jdt.debug/model/org/eclipse/jdt/internal/debug/core/model/JDIThread.java b/org.eclipse.jdt.debug/model/org/eclipse/jdt/internal/debug/core/model/JDIThread.java
index ece2b06..4301a39 100644
--- a/org.eclipse.jdt.debug/model/org/eclipse/jdt/internal/debug/core/model/JDIThread.java
+++ b/org.eclipse.jdt.debug/model/org/eclipse/jdt/internal/debug/core/model/JDIThread.java
@@ -3029,9 +3029,8 @@
 					return true;
 				}
 				if(!orig) {
-					IStepFilter[] contributedFilters = DebugPlugin.getStepFilters(JDIDebugPlugin.getUniqueIdentifier());
-					for (int i = 0; i < contributedFilters.length; i++) {
-						if (contributedFilters[i].isFiltered(method)) {
+					for (IStepFilter contributedFilter : DebugPlugin.getStepFilters(JDIDebugPlugin.getUniqueIdentifier())) {
+						if (contributedFilter.isFiltered(method)) {
 							return true;
 						}
 					}
diff --git a/org.eclipse.jdt.launching.ui.macosx/src/org/eclipse/jdt/internal/ui/macbundler/BundleBuilder.java b/org.eclipse.jdt.launching.ui.macosx/src/org/eclipse/jdt/internal/ui/macbundler/BundleBuilder.java
index 9f98ba2..415f0a0 100644
--- a/org.eclipse.jdt.launching.ui.macosx/src/org/eclipse/jdt/internal/ui/macbundler/BundleBuilder.java
+++ b/org.eclipse.jdt.launching.ui.macosx/src/org/eclipse/jdt/internal/ui/macbundler/BundleBuilder.java
@@ -39,7 +39,7 @@
 
 public class BundleBuilder implements BundleAttributes {
 
-	private List<Process> fProcesses= new ArrayList<Process>();
+	private List<Process> fProcesses= new ArrayList<>();
 	private BundleDescription fBundleDescription;
 
 
diff --git a/org.eclipse.jdt.launching.ui.macosx/src/org/eclipse/jdt/internal/ui/macbundler/BundleDescription.java b/org.eclipse.jdt.launching.ui.macosx/src/org/eclipse/jdt/internal/ui/macbundler/BundleDescription.java
index 1dc2b80..fa7ddd1 100644
--- a/org.eclipse.jdt.launching.ui.macosx/src/org/eclipse/jdt/internal/ui/macbundler/BundleDescription.java
+++ b/org.eclipse.jdt.launching.ui.macosx/src/org/eclipse/jdt/internal/ui/macbundler/BundleDescription.java
@@ -42,14 +42,14 @@
 	private static final String ICON= "/System/Library/Frameworks/JavaVM.framework/Versions/CurrentJDK/Resources/GenericApp.icns"; //$NON-NLS-1$
 	private static  Set<String> RUN_MODE;
 	{
-		RUN_MODE = new HashSet<String>();
+		RUN_MODE = new HashSet<>();
 		RUN_MODE.add(ILaunchManager.RUN_MODE);
 	}
 
 	private ListenerList<IPropertyChangeListener> fListeners= new ListenerList<>();
 	private Properties fProperties= new Properties();
-	private List<ResourceInfo> fClassPath= new ArrayList<ResourceInfo>();
-	private List<ResourceInfo> fResources= new ArrayList<ResourceInfo>();
+	private List<ResourceInfo> fClassPath= new ArrayList<>();
+	private List<ResourceInfo> fResources= new ArrayList<>();
 	Properties fProperties2= new Properties();
 
 
diff --git a/org.eclipse.jdt.launching.ui.macosx/src/org/eclipse/jdt/internal/ui/macbundler/BundleWizardPage1.java b/org.eclipse.jdt.launching.ui.macosx/src/org/eclipse/jdt/internal/ui/macbundler/BundleWizardPage1.java
index c655071..cc2138a 100644
--- a/org.eclipse.jdt.launching.ui.macosx/src/org/eclipse/jdt/internal/ui/macbundler/BundleWizardPage1.java
+++ b/org.eclipse.jdt.launching.ui.macosx/src/org/eclipse/jdt/internal/ui/macbundler/BundleWizardPage1.java
@@ -197,7 +197,7 @@
 	// private stuff
 
 	private void collectLaunchConfigs() {
-		ArrayList<ILaunchConfiguration> configs = new ArrayList<ILaunchConfiguration>();
+		ArrayList<ILaunchConfiguration> configs = new ArrayList<>();
 		ILaunchManager manager = DebugPlugin.getDefault().getLaunchManager();
 		ILaunchConfigurationType type = manager.getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION);
 		try {
diff --git a/org.eclipse.jdt.launching/launching/org/eclipse/jdt/internal/launching/environments/ExecutionEnvironment.java b/org.eclipse.jdt.launching/launching/org/eclipse/jdt/internal/launching/environments/ExecutionEnvironment.java
index c9f6844..1b05fa8 100644
--- a/org.eclipse.jdt.launching/launching/org/eclipse/jdt/internal/launching/environments/ExecutionEnvironment.java
+++ b/org.eclipse.jdt.launching/launching/org/eclipse/jdt/internal/launching/environments/ExecutionEnvironment.java
@@ -478,6 +478,13 @@
 			}
 
 		}
+		// For below Java 9 EE, compiler release option should be disabled by default
+		String property = profile.getProperty(JavaCore.COMPILER_COMPLIANCE);
+		if (property != null) {
+			if (JavaCore.compareJavaVersions(property, JavaCore.VERSION_9) < 0) {
+				profile.setProperty(JavaCore.COMPILER_RELEASE, JavaCore.DISABLED);
+			}
+		}
 		return profile;
 	}