diff --git a/org.eclipse.jdt.debug.tests/java7/Bug567801.java b/org.eclipse.jdt.debug.tests/java7/Bug567801.java
new file mode 100644
index 0000000..9d1d02f
--- /dev/null
+++ b/org.eclipse.jdt.debug.tests/java7/Bug567801.java
@@ -0,0 +1,17 @@
+import java.io.IOException;
+import java.sql.SQLException;
+
+public class Bug567801 {
+	public static void main(String[] args) {
+		try {
+			if(args.length == 0) {
+				throw new SQLException();
+			} else {
+				throw new IOException();
+			}
+		} catch(SQLException | IOException e) {
+			e.printStackTrace();
+		}
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.debug.tests/java8/Bug567801.java b/org.eclipse.jdt.debug.tests/java8/Bug567801.java
new file mode 100644
index 0000000..dd317d7
--- /dev/null
+++ b/org.eclipse.jdt.debug.tests/java8/Bug567801.java
@@ -0,0 +1,31 @@
+import java.io.Closeable;
+import java.io.IOException;
+import java.io.Serializable;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.IntStream;
+
+public class Bug567801 {
+	public static void main(String[] args) {
+		testBody();
+	}
+	private static <T extends Closeable & Serializable> void testBody() {
+		List<Integer> numbers = new ArrayList<>();
+		List<List<Integer>> listOfNumberList = new ArrayList<>();
+		List<? extends Number> extendsList = Arrays.asList(10,20);
+		List<? super Integer> superList = Arrays.asList(10,20);
+		List<?> wildList = Arrays.asList(10,20);
+		List<T> intersectionList = Collections.emptyList();
+		List<long[]> parrayList = Arrays.asList(new long[] {100L});
+		List<String[]> arrayList = Arrays.asList(new String[] {"100"}, new String[] {"200"});
+		IntStream stream = IntStream.of(10);
+
+		numbers.add(11);
+		listOfNumberList.add(numbers);
+		
+		System.out.println(numbers);
+	}
+}
\ No newline at end of file
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 a6f1483..4f3e8fd 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
@@ -433,6 +433,7 @@
 	        	jp = createProject(ONE_SEVEN_PROJECT_NAME, JavaProjectHelper.TEST_1_7_SRC_DIR.toString(), JavaProjectHelper.JAVA_SE_1_7_EE_NAME, false);
 	    		cfgs.add(createLaunchConfiguration(jp, LiteralTests17.LITERAL_TYPE_NAME));
 				cfgs.add(createLaunchConfiguration(jp, "ThreadNameChange"));
+				cfgs.add(createLaunchConfiguration(jp, "Bug567801"));
 	    		loaded17 = true;
 	    		waitForBuild();
 	        }
@@ -484,6 +485,7 @@
 				cfgs.add(createLaunchConfiguration(jp, "AnonymousEvaluator"));
 				cfgs.add(createLaunchConfiguration(jp, "Bug564486"));
 				cfgs.add(createLaunchConfiguration(jp, "Bug564801"));
+				cfgs.add(createLaunchConfiguration(jp, "Bug567801"));
 	    		loaded18 = true;
 	    		waitForBuild();
 	        }
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 dde4e60..2334837 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
@@ -92,6 +92,7 @@
 import org.eclipse.jdt.debug.tests.core.WorkspaceSourceContainerTests;
 import org.eclipse.jdt.debug.tests.eval.GeneralEvalTests;
 import org.eclipse.jdt.debug.tests.eval.GenericsEvalTests;
+import org.eclipse.jdt.debug.tests.eval.LambdaVariableTest;
 import org.eclipse.jdt.debug.tests.eval.SyntheticVariableTests;
 import org.eclipse.jdt.debug.tests.launching.ClasspathShortenerTests;
 import org.eclipse.jdt.debug.tests.launching.ConfigurationEncodingTests;
@@ -327,6 +328,9 @@
 
 	//add the complete eval suite
 		addTest(new TestSuite(GeneralEvalTests.class));
+		if (JavaProjectHelper.isJava8Compatible()) {
+			addTest(new TestSuite(LambdaVariableTest.class));
+		}
 		//addTest(EvalTestSuite.suite());
 
 		// long classpath tests
diff --git a/org.eclipse.jdt.debug.tests/tests/org/eclipse/jdt/debug/tests/eval/GenericsEval17Test.java b/org.eclipse.jdt.debug.tests/tests/org/eclipse/jdt/debug/tests/eval/GenericsEval17Test.java
new file mode 100644
index 0000000..041a240
--- /dev/null
+++ b/org.eclipse.jdt.debug.tests/tests/org/eclipse/jdt/debug/tests/eval/GenericsEval17Test.java
@@ -0,0 +1,57 @@
+/*******************************************************************************
+ * Copyright (c) 2020 Gayan Perera 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:
+ *     Gayan Perera - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jdt.debug.tests.eval;
+
+import org.eclipse.debug.core.model.IValue;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.debug.core.IJavaThread;
+import org.eclipse.jdt.debug.tests.AbstractDebugTest;
+
+public class GenericsEval17Test extends AbstractDebugTest {
+	private IJavaThread javaThread;
+
+	@Override
+	protected IJavaProject getProjectContext() {
+		return get17Project();
+	}
+
+	public GenericsEval17Test(String name) {
+		super(name);
+	}
+
+	public void testEvaluate_Bug567801_UnionType_ExpectValueType() throws Exception {
+		debugWithBreakpoint("Bug567801", 13);
+		String snippet = "e instanceof java.lang.Exception";
+		IValue value = doEval(javaThread, snippet);
+
+		assertNotNull("value is null", value);
+		assertEquals("value is not true", "true", value.getValueString());
+	}
+
+	private void debugWithBreakpoint(String testClass, int lineNumber) throws Exception {
+		createLineBreakpoint(lineNumber, testClass);
+		javaThread = launchToBreakpoint(testClass);
+		assertNotNull("The program did not suspend", javaThread);
+	}
+
+	@Override
+	protected void tearDown() throws Exception {
+		try {
+			terminateAndRemove(javaThread);
+		} finally {
+			super.tearDown();
+			removeAllBreakpoints();
+		}
+	}
+}
diff --git a/org.eclipse.jdt.debug.tests/tests/org/eclipse/jdt/debug/tests/eval/LambdaVariableTest.java b/org.eclipse.jdt.debug.tests/tests/org/eclipse/jdt/debug/tests/eval/LambdaVariableTest.java
index 4ff72ea..53b5be3 100644
--- a/org.eclipse.jdt.debug.tests/tests/org/eclipse/jdt/debug/tests/eval/LambdaVariableTest.java
+++ b/org.eclipse.jdt.debug.tests/tests/org/eclipse/jdt/debug/tests/eval/LambdaVariableTest.java
@@ -64,6 +64,87 @@
 		assertEquals("Actual value is not false", "false", value.toString());
 	}
 
+	public void testEvaluate_Bug567801_VariableWithTypeArgument_MustEvaluationWithCorrectType() throws Exception {
+		debugWithBreakpoint("Bug567801", 29);
+		String snippet = "numbers.stream().anyMatch(a -> a >= 10)";
+		IValue value = doEval(javaThread, snippet);
+
+		assertEquals("wrong type : ", "boolean", value.getReferenceTypeName());
+		assertEquals("Actual value is not true", "true", value.getValueString());
+	}
+
+	public void testEvaluate_Bug567801_VariableWithNestedTypeArgument_MustEvaluationWithCorrectType() throws Exception {
+		debugWithBreakpoint("Bug567801", 29);
+		String snippet = "listOfNumberList.stream().filter(l -> l.size() > 0).flatMap(l -> l.stream()).anyMatch(a -> a >= 10)";
+		IValue value = doEval(javaThread, snippet);
+
+		assertEquals("wrong type : ", "boolean", value.getReferenceTypeName());
+		assertEquals("Actual value is not true", "true", value.getValueString());
+	}
+
+	public void testEvaluate_Bug567801_VariableWithUpperBoundTypeArgument_MustEvaluationWithCorrectType() throws Exception {
+		debugWithBreakpoint("Bug567801", 29);
+		String snippet = "extendsList.stream().anyMatch(a -> a.intValue() >= 10)";
+		IValue value = doEval(javaThread, snippet);
+
+		assertEquals("wrong type : ", "boolean", value.getReferenceTypeName());
+		assertEquals("Actual value is not true", "true", value.getValueString());
+	}
+
+	public void testEvaluate_Bug567801_VariableWithLowerBoundTypeArgument_MustEvaluationWithCorrectType() throws Exception {
+		debugWithBreakpoint("Bug567801", 29);
+		String snippet = "superList.stream().anyMatch(a -> ((Integer)a).intValue() >= 10)";
+		IValue value = doEval(javaThread, snippet);
+
+		assertEquals("wrong type : ", "boolean", value.getReferenceTypeName());
+		assertEquals("Actual value is not true", "true", value.getValueString());
+	}
+
+	public void testEvaluate_Bug567801_VariableWithWildCardTypeArgument_MustEvaluationWithCorrectType() throws Exception {
+		debugWithBreakpoint("Bug567801", 29);
+		String snippet = "wildList.stream().anyMatch(a -> ((Integer)a).intValue() >= 10)";
+		IValue value = doEval(javaThread, snippet);
+
+		assertEquals("wrong type : ", "boolean", value.getReferenceTypeName());
+		assertEquals("Actual value is not true", "true", value.getValueString());
+	}
+
+	public void testEvaluate_Bug567801_VariableWithIntersectionTypeArgument_MustEvaluationWithCorrectType() throws Exception {
+		debugWithBreakpoint("Bug567801", 29);
+		String snippet = "intersectionList.stream().anyMatch(a -> a instanceof java.io.Closeable)";
+		IValue value = doEval(javaThread, snippet);
+
+		assertEquals("wrong type : ", "boolean", value.getReferenceTypeName());
+		assertEquals("Actual value is not false", "false", value.getValueString());
+	}
+
+	public void testEvaluate_Bug567801_VariableWithPrimitiveArrayTypeArgument_MustEvaluationWithCorrectType() throws Exception {
+		debugWithBreakpoint("Bug567801", 29);
+		String snippet = "parrayList.stream().anyMatch(a -> a.length > 0)";
+		IValue value = doEval(javaThread, snippet);
+
+		assertEquals("wrong type : ", "boolean", value.getReferenceTypeName());
+		assertEquals("Actual value is not true", "true", value.getValueString());
+	}
+
+	public void testEvaluate_Bug567801_VariableWithArrayTypeArgument_MustEvaluationWithCorrectType() throws Exception {
+		debugWithBreakpoint("Bug567801", 29);
+		String snippet = "arrayList.stream().anyMatch(a -> a.length > 0)";
+		IValue value = doEval(javaThread, snippet);
+
+		assertEquals("wrong type : ", "boolean", value.getReferenceTypeName());
+		assertEquals("Actual value is not true", "true", value.getValueString());
+	}
+
+	public void testEvaluate_Bug567801_PrimitiveTypeArgument_MustEvaluationWithCorrectType() throws Exception {
+		debugWithBreakpoint("Bug567801", 29);
+		String snippet = "stream.anyMatch(a -> a > 0)";
+		IValue value = doEval(javaThread, snippet);
+
+		assertEquals("wrong type : ", "boolean", value.getReferenceTypeName());
+		assertEquals("Actual value is not true", "true", value.getValueString());
+	}
+
 	private void debugWithBreakpoint(String testClass, int lineNumber) throws Exception {
 		createLineBreakpoint(lineNumber, testClass);
 		javaThread = launchToBreakpoint(testClass);
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
index 0e4531e..149ff12 100644
--- 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
@@ -249,6 +249,18 @@
 			return localBindings.containsKey(binding);
 		}
 
+		private boolean isParentInLocalBinding(ASTNode parent) {
+			if (parent instanceof Name) {
+				// this will avoid unwanted upward traversals
+				if (isLocalBinding(((Name) parent).resolveBinding())) {
+					return true;
+				}
+				// traverse upstream to see if a parent is already handled
+				return isParentInLocalBinding(parent.getParent());
+			}
+			return false;
+		}
+
 		void addLocalBinding(IBinding binding, String name) {
 			localBindings.put(binding, name);
 		}
@@ -1494,7 +1506,10 @@
 		@Override
 		public boolean visit(SimpleName node) {
 			IBinding binding = node.resolveBinding();
-			if (!isLocalBinding(binding)) {
+			// when having code like arr.length the length is identified as a field variable. But since the arr is
+			// already pushed as a variable we don't need to handle length here. So if we have chained field access like
+			// obj.f1.f2 we will only push the obj as a variable.
+			if (!isLocalBinding(binding) && isParentInLocalBinding(node.getParent())) {
 				if (binding instanceof IVariableBinding) {
 					IVariableBinding vb = ((IVariableBinding) binding);
 					// For future optimization: Check for duplicates, so same value is only bound once
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 b5be5c5..d9dc4ae 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
@@ -42,6 +42,7 @@
 import org.eclipse.debug.core.model.IVariable;
 import org.eclipse.jdt.core.IJavaProject;
 import org.eclipse.jdt.core.Signature;
+import org.eclipse.jdt.core.compiler.CharOperation;
 import org.eclipse.jdt.core.compiler.IProblem;
 import org.eclipse.jdt.core.dom.AST;
 import org.eclipse.jdt.core.dom.ASTParser;
@@ -80,6 +81,7 @@
 public class ASTEvaluationEngine implements IAstEvaluationEngine {
 	public static final String ANONYMOUS_VAR_PREFIX = "val$"; //$NON-NLS-1$
 	private static final int EVALUATION_DETAIL_BITMASK = DebugEvent.EVALUATION | DebugEvent.EVALUATION_IMPLICIT;
+	private static final String QN_OBJECT = "java.lang.Object"; //$NON-NLS-1$
 	private IJavaProject fProject;
 
 	private IJavaDebugTarget fDebugTarget;
@@ -403,19 +405,63 @@
 	}
 
 	private String getFixedUnresolvableGenericTypes(IJavaVariable variable) throws DebugException {
+		StringBuilder fixedSignature = new StringBuilder();
+		scanAndFixSignature(variable.getGenericSignature(), Signature.toString(variable.getSignature()), fixedSignature);
+		return fixedSignature.toString();
+	}
+
+	private void scanAndFixSignature(String genericSignature, String erasureSignature, StringBuilder fixedSignature) {
 		/*
 		 * This actually fix variables which are type of Generic Types which cannot be resolved to a type in the current content. For example variable
 		 * type like P_OUT in java.util.stream.ReferencePipeline.filter(Predicate<? super P_OUT>)
+		 *
+		 * and also generic signature such as Ljava/util/function/Predicate<+Ljava/util/List<Ljava/lang/Integer;>;>; Ljava/util/Comparator<-TT;>;
+		 * which will fail the properly resolved to the type.
 		 */
-
-		final String genericSignature = variable.getGenericSignature();
-		final String fqn = Signature.toString(genericSignature).replace('/', '.');
-		if (genericSignature.startsWith(String.valueOf(Signature.C_TYPE_VARIABLE))
-				|| Signature.getTypeArguments(genericSignature).length > 0) {
-			// resolve to the signature of the variable.
-			return Signature.toString(variable.getSignature()).replace('/', '.');
+		if (genericSignature.startsWith(String.valueOf(Signature.C_TYPE_VARIABLE)) ||
+				genericSignature.startsWith(String.valueOf(Signature.C_CAPTURE)) ||
+				genericSignature.startsWith(String.valueOf(Signature.C_STAR)) ||
+				genericSignature.startsWith(String.valueOf(Signature.C_SUPER)))
+		{
+			fixedSignature.append(toDotQualified(erasureSignature));
+			return;
 		}
-		return fqn;
+
+		if(genericSignature.startsWith(String.valueOf(Signature.C_EXTENDS))) {
+			fixedSignature.append(toDotQualified(Signature.toString(getUpperBoundTypeSignature(genericSignature))));
+			return;
+		}
+
+		// we have a proper type which might be parameterized so extract the type FQN
+		fixedSignature.append(toDotQualified(Signature.toString(Signature.getTypeErasure(genericSignature))));
+
+		String[] typeArguments = Signature.getTypeArguments(genericSignature);
+		if (typeArguments.length > 0) {
+			fixedSignature.append(Signature.C_GENERIC_START);
+			for (int i = 0; i < typeArguments.length; i++) {
+				if (i > 0) {
+					fixedSignature.append(',');
+				}
+				scanAndFixSignature(typeArguments[i], QN_OBJECT, fixedSignature);
+			}
+			fixedSignature.append(Signature.C_GENERIC_END);
+		}
+	}
+
+	private String toDotQualified(String fqn) {
+		return fqn.replace('/', '.');
+	}
+
+	private String getUpperBoundTypeSignature(String typeParamaterSignature) {
+		// +Ljava/util/List<Ljava/lang/Integer;>;
+		return String.valueOf(getBoudTypeParameterSignature(typeParamaterSignature.toCharArray(), Signature.C_EXTENDS));
+	}
+
+	private char[] getBoudTypeParameterSignature(char[] typeParamaterSignature, char boundType) {
+		if (typeParamaterSignature.length < 2 || typeParamaterSignature[0] != boundType) {
+			throw new IllegalArgumentException(Signature.toString(String.valueOf(typeParamaterSignature)));
+		}
+		return CharOperation.subarray(typeParamaterSignature, 1, typeParamaterSignature.length);
 	}
 
 	private CompilationUnit parseCompilationUnit(char[] source,
@@ -481,11 +527,11 @@
 			// Arrays with a base component type of a class or interface are
 			// treated
 			// as Object arrays and evaluated in Object.
-			String recTypeName = "java.lang.Object"; //$NON-NLS-1$
+			String recTypeName = QN_OBJECT;
 			String typeName = arrayType.getName();
 			if (componentType instanceof IJavaReferenceType) {
 				StringBuilder buf = new StringBuilder();
-				buf.append("java.lang.Object"); //$NON-NLS-1$
+				buf.append(QN_OBJECT);
 				for (int i = 0; i < dimension; i++) {
 					buf.append("[]"); //$NON-NLS-1$
 				}