diff --git a/groovy-eclipse.setup b/groovy-eclipse.setup
index acd6db1a65..e2e81861da 100644
--- a/groovy-eclipse.setup
+++ b/groovy-eclipse.setup
@@ -293,7 +293,7 @@
         <repository
             url="https://download.eclipse.org/eclipse/updates/4.21"/>
         <repository
-            url="https://download.eclipse.org/eclipse/updates/4.21-I-builds/I20210729-1800"/>
+            url="https://download.eclipse.org/eclipse/updates/4.21-I-builds/I20210818-1800"/>
       </repositoryList>
       <repositoryList
           name="2021-06">
diff --git a/jdt-patch/e421/Feature-org.codehaus.groovy.jdt.patch/feature.xml b/jdt-patch/e421/Feature-org.codehaus.groovy.jdt.patch/feature.xml
index 2d52a92187..d15955eaa5 100644
--- a/jdt-patch/e421/Feature-org.codehaus.groovy.jdt.patch/feature.xml
+++ b/jdt-patch/e421/Feature-org.codehaus.groovy.jdt.patch/feature.xml
@@ -18,7 +18,7 @@
    </license>
 
    <requires>
-      <import feature="org.eclipse.jdt" version="3.18.900.v20210729-1800" patch="true"/>
+      <import feature="org.eclipse.jdt" version="3.18.900.v20210818-1800" patch="true"/>
    </requires>
 
    <plugin
diff --git a/jdt-patch/e421/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/parser/CompletionParserTest2.java b/jdt-patch/e421/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/parser/CompletionParserTest2.java
index 14f7784a01..7247ee2492 100644
--- a/jdt-patch/e421/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/parser/CompletionParserTest2.java
+++ b/jdt-patch/e421/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/parser/CompletionParserTest2.java
@@ -7346,7 +7346,7 @@ public void test0112_Method(){
 	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";
 	String expectedParentNodeToString = "(1 == <CompleteOnName:zzz>)";
 	String completionIdentifier = "zzz";
-	String expectedReplacedSource = "(zzz)";
+	String expectedReplacedSource = "zzz";
 	String expectedUnitDisplayString =
 			"package p;\n" +
 			"public class X {\n" +
diff --git a/jdt-patch/e421/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/parser/CompletionRecoveryTest.java b/jdt-patch/e421/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/parser/CompletionRecoveryTest.java
index 03235db715..a88209d57b 100644
--- a/jdt-patch/e421/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/parser/CompletionRecoveryTest.java
+++ b/jdt-patch/e421/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/parser/CompletionRecoveryTest.java
@@ -758,6 +758,7 @@ public void test18() {
 		"      int hello() {\n" +
 		"      }\n" +
 		"    }\n" +
+		"    <CompleteOnName:>;\n" +
 		"  }\n" +
 		"}\n",
 		// expectedCompletionIdentifier:
diff --git a/jdt-patch/e421/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/PatternMatching16Test.java b/jdt-patch/e421/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/PatternMatching16Test.java
index 2b27609544..f853c26f9b 100644
--- a/jdt-patch/e421/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/PatternMatching16Test.java
+++ b/jdt-patch/e421/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/PatternMatching16Test.java
@@ -12,8 +12,11 @@
  *******************************************************************************/
 package org.eclipse.jdt.core.tests.compiler.regression;
 
+import java.io.IOException;
 import java.util.Map;
 
+import org.eclipse.jdt.core.util.ClassFileBytesDisassembler;
+import org.eclipse.jdt.core.util.ClassFormatException;
 import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
 
 import junit.framework.Test;
@@ -3876,4 +3879,89 @@ public void testBug574906() {
                 "true",
                 options);
     }
+    public void testBug575035() throws ClassFormatException, IOException {
+        Map<String, String> options = getCompilerOptions(false);
+    	String source =
+    			"import java.lang.annotation.ElementType;\n" +
+    			"import java.lang.annotation.Retention;\n" +
+    			"import java.lang.annotation.RetentionPolicy;\n" +
+    			"import java.lang.annotation.Target;\n" +
+    			" \n" +
+    			"public class Test {\n" +
+    			"    @Target({ ElementType.LOCAL_VARIABLE})\n" +
+    			"    @Retention(RetentionPolicy.RUNTIME)\n" +
+    			"    @interface Var {}\n" +
+    			"    @Target({ ElementType.TYPE_USE})\n" +
+    			"    @Retention(RetentionPolicy.RUNTIME)\n" +
+    			"    @interface Type {}\n" +
+    			"    public static void main(String[] args) {" +
+    			"        @Var @Type String y = \"OK: \";\n" +
+    			"        if (((Object)\"local\") instanceof @Var @Type String x) {\n" +
+    			"            System.out.println(y + x);\n" +
+    			"        }\n" +
+    		    "    }\n" +
+    			"}";
+    	String expectedOutput = ""
+    			+ "  // Method descriptor #15 ([Ljava/lang/String;)V\n"
+    			+ "  // Stack: 4, Locals: 4\n"
+    			+ "  public static void main(String[] args);\n"
+    			+ "     0  ldc <String \"OK: \"> [16]\n"
+    			+ "     2  astore_1 [y]\n"
+    			+ "     3  ldc <String \"local\"> [18]\n"
+    			+ "     5  astore_3 [ instanceOfPatternExpressionValue]\n"
+    			+ "     6  aload_3 [ instanceOfPatternExpressionValue]\n"
+    			+ "     7  instanceof String [20]\n"
+    			+ "    10  ifeq 50\n"
+    			+ "    13  aload_3 [ instanceOfPatternExpressionValue]\n"
+    			+ "    14  checkcast String [20]\n"
+    			+ "    17  dup\n"
+    			+ "    18  astore_2\n"
+    			+ "    19  aload_3\n"
+    			+ "    20  checkcast String [20]\n"
+    			+ "    23  if_acmpne 50\n"
+    			+ "    26  getstatic System.out : PrintStream [22]\n"
+    			+ "    29  new StringBuilder [28]\n"
+    			+ "    32  dup\n"
+    			+ "    33  aload_1 [y]\n"
+    			+ "    34  invokestatic String.valueOf(Object) : String [30]\n"
+    			+ "    37  invokespecial StringBuilder(String) [34]\n"
+    			+ "    40  aload_2 [x]\n"
+    			+ "    41  invokevirtual StringBuilder.append(String) : StringBuilder [37]\n"
+    			+ "    44  invokevirtual StringBuilder.toString() : String [41]\n"
+    			+ "    47  invokevirtual PrintStream.println(String) : void [45]\n"
+    			+ "    50  return\n"
+    			+ "      Line numbers:\n"
+    			+ "        [pc: 0, line: 13]\n"
+    			+ "        [pc: 3, line: 14]\n"
+    			+ "        [pc: 26, line: 15]\n"
+    			+ "        [pc: 50, line: 17]\n"
+    			+ "      Local variable table:\n"
+    			+ "        [pc: 0, pc: 51] local: args index: 0 type: String[]\n"
+    			+ "        [pc: 3, pc: 51] local: y index: 1 type: String\n"
+    			+ "        [pc: 26, pc: 50] local: x index: 2 type: String\n"
+    			+ "        [pc: 6, pc: 20] local:  instanceOfPatternExpressionValue index: 3 type: Object\n"
+    			+ "      Stack map table: number of frames 1\n"
+    			+ "        [pc: 50, append: {String}]\n"
+    			+ "    RuntimeVisibleTypeAnnotations: \n"
+    			+ "      #59 @Type(\n"
+    			+ "        target type = 0x40 LOCAL_VARIABLE\n"
+    			+ "        local variable entries:\n"
+    			+ "          [pc: 3, pc: 51] index: 1\n"
+    			+ "      )\n"
+    			+ "      #59 @Type(\n"
+    			+ "        target type = 0x40 LOCAL_VARIABLE\n"
+    			+ "        local variable entries:\n"
+    			+ "          [pc: 26, pc: 50] index: 2\n"
+    			+ "      )\n"
+    			+ "\n";
+    	checkClassFile("Test", source, expectedOutput, ClassFileBytesDisassembler.DETAILED | ClassFileBytesDisassembler.COMPACT);
+        runConformTest(
+                new String[] {
+                        "Test.java",
+                        source,
+                },
+                "OK: local",
+                options);
+
+    }
 }
diff --git a/jdt-patch/e421/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/util/AbstractCompilerTest.java b/jdt-patch/e421/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/util/AbstractCompilerTest.java
index a705a2befa..35b6bba070 100644
--- a/jdt-patch/e421/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/util/AbstractCompilerTest.java
+++ b/jdt-patch/e421/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/util/AbstractCompilerTest.java
@@ -321,7 +321,11 @@ public static int getPossibleComplianceLevels() {
 			isJRE10Plus = isJRE11Plus || CompilerOptions.VERSION_10.equals(specVersion);
 			isJRE9Plus = isJRE10Plus || CompilerOptions.VERSION_9.equals(specVersion);
 			initReflectionVersion();
-			String compliances = System.getProperty("compliance");
+			String key = "compliance.jre." + specVersion;
+			String compliances = System.getProperty(key);
+			if (compliances == null) {
+				compliances = System.getProperty("compliance");
+			}
 			if (compliances != null) {
 				possibleComplianceLevels = 0;
 				for (String compliance : compliances.split(",")) {
diff --git a/jdt-patch/e421/org.eclipse.jdt.core.tests.compiler/test.xml b/jdt-patch/e421/org.eclipse.jdt.core.tests.compiler/test.xml
index afe7e7ccfb..53a33770d2 100644
--- a/jdt-patch/e421/org.eclipse.jdt.core.tests.compiler/test.xml
+++ b/jdt-patch/e421/org.eclipse.jdt.core.tests.compiler/test.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 
 <!--
-    Copyright (c) 2002, 2014 IBM Corporation and others.
+    Copyright (c) 2002, 2021 IBM Corporation and others.
 
     This program and the accompanying materials
     are made available under the terms of the Eclipse Public License 2.0
@@ -56,6 +56,9 @@
       <property name="plugin-name" value="${plugin-name}"/>
       <property name="classname" 
                 value="org.eclipse.jdt.core.tests.compiler.regression.TestAll"/>
+      <property name="vmargs" 
+      	value="-Dcompliance.jre.11=1.8,9,10,11 -Dcompliance.jre.16=1.8,11,15,16 -Dcompliance.jre.17=1.8,11,16,17"
+      />
     </ant>
 
 	<antcall target="evaluation_tests"/>
diff --git a/jdt-patch/e421/org.eclipse.jdt.core/.settings/.api_filters b/jdt-patch/e421/org.eclipse.jdt.core/.settings/.api_filters
index eb740a6508..8b98c17003 100644
--- a/jdt-patch/e421/org.eclipse.jdt.core/.settings/.api_filters
+++ b/jdt-patch/e421/org.eclipse.jdt.core/.settings/.api_filters
@@ -8,6 +8,15 @@
             </message_arguments>
         </filter>
     </resource>
+    <resource path="dom/org/eclipse/jdt/core/dom/ASTNode.java" type="org.eclipse.jdt.core.dom.ASTNode">
+        <filter comment="To fix the mistake and considering nodes added till 107 in BETA Branch" id="388194388">
+            <message_arguments>
+                <message_argument value="org.eclipse.jdt.core.dom.ASTNode"/>
+                <message_argument value="MODULE_QUALIFIED_NAME"/>
+                <message_argument value="103"/>
+            </message_arguments>
+        </filter>
+    </resource>
     <resource path="dom/org/eclipse/jdt/core/dom/Annotation.java" type="org.eclipse.jdt.core.dom.Annotation">
         <filter id="576725006">
             <message_arguments>
diff --git a/jdt-patch/e421/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/CompletionEngine.java b/jdt-patch/e421/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/CompletionEngine.java
index 0579e98e4e..ffc25a0f41 100644
--- a/jdt-patch/e421/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/CompletionEngine.java
+++ b/jdt-patch/e421/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/CompletionEngine.java
@@ -68,8 +68,9 @@
 import org.eclipse.jdt.internal.codeassist.complete.CompletionNodeFound;
 import org.eclipse.jdt.internal.codeassist.complete.CompletionOnAnnotationOfType;
 import org.eclipse.jdt.internal.codeassist.complete.CompletionOnArgumentName;
-import org.eclipse.jdt.internal.codeassist.complete.CompletionOnBranchStatementLabel;
+import org.eclipse.jdt.internal.codeassist.complete.CompletionOnBreakStatement;
 import org.eclipse.jdt.internal.codeassist.complete.CompletionOnClassLiteralAccess;
+import org.eclipse.jdt.internal.codeassist.complete.CompletionOnContinueStatement;
 import org.eclipse.jdt.internal.codeassist.complete.CompletionOnExplicitConstructorCall;
 import org.eclipse.jdt.internal.codeassist.complete.CompletionOnFieldName;
 import org.eclipse.jdt.internal.codeassist.complete.CompletionOnFieldType;
@@ -2020,8 +2021,10 @@ private boolean complete(
 			completionOnMarkerAnnotationName(astNode, qualifiedBinding, scope);
 		} else if (astNode instanceof CompletionOnMemberValueName) {
 			completionOnMemberValueName(astNode, astNodeParent, scope, insideTypeAnnotation);
-		} else if(astNode instanceof CompletionOnBranchStatementLabel) {
-			completionOnBranchStatementLabel(astNode);
+		} else if(astNode instanceof CompletionOnBreakStatement) {
+			completionOnBreakStatement((CompletionOnBreakStatement) astNode);
+		} else if(astNode instanceof CompletionOnContinueStatement) {
+			completionOnContinueStatement((CompletionOnContinueStatement) astNode);
 		} else if(astNode instanceof CompletionOnMessageSendName) {
 			completionOnMessageSendName(astNode, qualifiedBinding, scope);
 		} else if (astNode instanceof CompletionOnReferenceExpressionName) {
@@ -2608,11 +2611,17 @@ public void complete(IType type, char[] snippet, int position, char[][] localVar
 		}
 	}
 
-	private void completionOnBranchStatementLabel(ASTNode astNode) {
+	private void completionOnBreakStatement(CompletionOnBreakStatement astNode) {
 		if (!this.requestor.isIgnored(CompletionProposal.LABEL_REF)) {
-			CompletionOnBranchStatementLabel label = (CompletionOnBranchStatementLabel) astNode;
-			this.completionToken = label.label;
-			findLabels(this.completionToken, label.possibleLabels);
+			this.completionToken = astNode.label;
+			findLabels(this.completionToken, astNode.possibleLabels);
+		}
+	}
+
+	private void completionOnContinueStatement(CompletionOnContinueStatement astNode) {
+		if (!this.requestor.isIgnored(CompletionProposal.LABEL_REF)) {
+			this.completionToken = astNode.label;
+			findLabels(this.completionToken, astNode.possibleLabels);
 		}
 	}
 
@@ -3240,6 +3249,7 @@ private void completionOnMessageSendName(ASTNode astNode, Binding qualifiedBindi
 			if (messageSend.nextIsCast) {
 				// optionalPrefix|((String) s) was mistaken as a messageSend(?). Treat like beginning of statement.
 				findVariablesAndMethods(this.completionToken, scope, messageSend, scope, false, false);
+				findTypesAndPackages(this.completionToken, scope, true, false, new ObjectVector());
 				return;
 			}
 
@@ -3694,6 +3704,17 @@ private void completionOnQualifiedTypeReference(ASTNode astNode, ASTNode astNode
 				}
 			}
 		} else if (qualifiedBinding instanceof ReferenceBinding && !(qualifiedBinding instanceof TypeVariableBinding)) {
+			ReferenceBinding receiverType = (ReferenceBinding) qualifiedBinding;
+			if (astNodeParent instanceof LocalDeclaration && ref.nextToken == TerminalTokens.TokenNameLPAREN && !this.assistNodeIsConstructor) {
+				// the subsequent '(' makes the interpretation as LocalDeclaration illegal (unless it's "new prefix.token()").
+				// therefore we assume that "name(" (where name is LocalDeclaration.name) is the start of a new statement,
+				// and propose *everything* that can be referenced via the receiverType:
+				findMethods(this.completionToken, null, null, receiverType, scope, new ObjectVector(), true/*onlyStatic*/, false,
+						FakeInvocationSite, scope, false, false, false, null, null, null, false, null, -1, -1);
+				findFields(this.completionToken, receiverType, scope, new ObjectVector(), new ObjectVector(), true/*onlyStatic*/,
+						FakeInvocationSite, scope, false, false, null, null, null, false, null, -1, -1);
+				// fall through to propose member types
+			}
 			if (!this.requestor.isIgnored(CompletionProposal.TYPE_REF)) {
 				setSourceAndTokenRange((int) (completionPosition >>> 32), (int) completionPosition);
 
@@ -3702,7 +3723,7 @@ private void completionOnQualifiedTypeReference(ASTNode astNode, ASTNode astNode
 				if (this.assistNodeIsException && astNodeParent instanceof TryStatement) {
 					findExceptionFromTryStatement(
 							this.completionToken,
-							(ReferenceBinding)qualifiedBinding,
+							receiverType,
 							scope.enclosingSourceType(),
 							(BlockScope)scope,
 							typesFound);
@@ -3712,7 +3733,7 @@ private void completionOnQualifiedTypeReference(ASTNode astNode, ASTNode astNode
 
 				findMemberTypes(
 					this.completionToken,
-					(ReferenceBinding) qualifiedBinding,
+					receiverType,
 					scope,
 					scope.enclosingSourceType(),
 					false,
@@ -3731,12 +3752,22 @@ private void completionOnQualifiedTypeReference(ASTNode astNode, ASTNode astNode
 			findTypesAndSubpackages(this.completionToken, (PackageBinding) qualifiedBinding, scope);
 		}
 		ASTNode parentNode = this.parser.assistNodeParent;
-		if (ref.tokens.length == 1 && parentNode instanceof LocalDeclaration && ((LocalDeclaration) parentNode).type == ref) {
+		if (ref.tokens.length > 0 && parentNode instanceof LocalDeclaration && ((LocalDeclaration) parentNode).type == ref) {
 			// additionally check if 'prefix.' should be interpreted as a variable receiver rather then part of a type reference:
 			Binding variable = scope.getBinding(ref.tokens[0], Binding.VARIABLE, FakeInvocationSite, true);
-			if (variable instanceof VariableBinding) {
+			lookupViaVariable: if (variable instanceof VariableBinding) {
 				TypeBinding receiverType = ((VariableBinding) variable).type;
-				if (receiverType != null && receiverType.isValidBinding()) {
+				int len = ref.tokens.length;
+				for (int i=1; i<len; i++) {
+					// lookup subsequent fields in 'prefix.q.r.'
+					if (!(receiverType instanceof ReferenceBinding && receiverType.isValidBinding()))
+						break lookupViaVariable;
+					FieldBinding field = scope.getField(receiverType, ref.tokens[i], FakeInvocationSite);
+					if (!field.isValidBinding())
+						break lookupViaVariable;
+					receiverType = field.type;
+				}
+				if (receiverType instanceof ReferenceBinding && receiverType.isValidBinding()) {
 					findFieldsAndMethods(this.completionToken, receiverType, scope, new ObjectVector(), new ObjectVector(), FakeInvocationSite, scope, false, false, null, null, null, false, null, ref.sourceStart, (int)ref.sourcePositions[0]);
 				}
 			}
@@ -3897,8 +3928,15 @@ else if ( astNodeParent instanceof InstanceOfExpression) {
 			if (receiverType != null && receiverType.isValidBinding()) {
 				findVariablesAndMethods(this.completionToken, scope, FakeInvocationSite, scope, false, false);
 			}
+			// ... or a keyword (possibly starting a new statement):
+			if (!this.requestor.isIgnored(CompletionProposal.KEYWORD)) {
+				if (this.completionToken != null && this.completionToken.length != 0) {
+					findKeywords(this.completionToken, singleRef.possibleKeywords, false, false);
+				} else {
+					findTrueOrFalseKeywords(singleRef.possibleKeywords);
+				}
+			}
 		}
-
 	}
 
 	private void completionOnProvidesInterfacesSingleTypeReference(ASTNode astNode, ASTNode astNodeParent, Binding qualifiedBinding, Scope scope) {
diff --git a/jdt-patch/e421/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/SelectionEngine.java b/jdt-patch/e421/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/SelectionEngine.java
index 2aa4cdaade..c523b4e534 100644
--- a/jdt-patch/e421/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/SelectionEngine.java
+++ b/jdt-patch/e421/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/SelectionEngine.java
@@ -49,6 +49,7 @@
 import org.eclipse.jdt.internal.codeassist.select.SelectionOnPackageVisibilityReference;
 import org.eclipse.jdt.internal.codeassist.select.SelectionOnImportReference;
 import org.eclipse.jdt.internal.codeassist.select.SelectionOnLocalName;
+import org.eclipse.jdt.internal.codeassist.select.SelectionOnMessageSend;
 import org.eclipse.jdt.internal.codeassist.select.SelectionOnPackageReference;
 import org.eclipse.jdt.internal.codeassist.select.SelectionOnQualifiedTypeReference;
 import org.eclipse.jdt.internal.codeassist.select.SelectionOnSingleTypeReference;
@@ -64,6 +65,7 @@
 import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration;
 import org.eclipse.jdt.internal.compiler.ast.ImportReference;
 import org.eclipse.jdt.internal.compiler.ast.LocalDeclaration;
+import org.eclipse.jdt.internal.compiler.ast.MessageSend;
 import org.eclipse.jdt.internal.compiler.ast.MethodDeclaration;
 import org.eclipse.jdt.internal.compiler.ast.ModuleDeclaration;
 import org.eclipse.jdt.internal.compiler.ast.PackageVisibilityStatement;
@@ -1425,6 +1427,12 @@ private void selectLocalDeclaration(ASTNode node) {
 		// for traversing the parse tree, the parser assist identifier is necessary for identitiy checks
 		final char[] assistIdentifier = getParser().assistIdentifier();
 		if (assistIdentifier == null) return;
+		final BlockScope nodeScope;
+		if (node instanceof AbstractMethodDeclaration) {
+			nodeScope = ((AbstractMethodDeclaration)node).scope;
+		} else {
+			nodeScope = null;
+		}
 
 		class Visitor extends ASTVisitor {
 			@Override
@@ -1490,6 +1498,19 @@ public boolean visit(MethodDeclaration methodDeclaration, ClassScope scope) {
 				return true;
 			}
 			@Override
+			public boolean visit(MessageSend messageSend, BlockScope scope) {
+				if (messageSend.selector == assistIdentifier && messageSend instanceof SelectionOnMessageSend) {
+					if (scope == null) {
+						scope = nodeScope;
+					}
+					if (scope != null) {
+						messageSend.resolve(scope);
+						throw new SelectionNodeFound(messageSend.binding);
+					}
+				}
+				return true;
+			}
+			@Override
 			public boolean visit(
 		    		Argument argument, BlockScope scope) {
 				if (argument.type instanceof SingleTypeReference && ((SingleTypeReference)argument.type).token == assistIdentifier)
diff --git a/jdt-patch/e421/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionNodeDetector.java b/jdt-patch/e421/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionNodeDetector.java
index 929cbe1c7a..6aeda7a672 100644
--- a/jdt-patch/e421/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionNodeDetector.java
+++ b/jdt-patch/e421/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionNodeDetector.java
@@ -24,6 +24,28 @@
  */
 public class CompletionNodeDetector extends ASTVisitor {
 
+	static class FindAny extends GenericAstVisitor {
+		private ASTNode searchFor;
+		boolean found;
+
+		public FindAny(ASTNode searchFor) {
+			this.searchFor = searchFor;
+		}
+
+		@Override
+		protected boolean visitNode(ASTNode node) {
+			if (node == this.searchFor) {
+				this.found = true;
+			}
+			return !this.found;
+		}
+	}
+	public static boolean findAny(CompilationUnitDeclaration unit, ASTNode searchFor) {
+		FindAny visitor = new FindAny(searchFor);
+		unit.traverse(visitor, (CompilationUnitScope)null, false);
+		return visitor.found;
+	}
+
 	@SuppressWarnings("serial")
 	static class StopTraversal extends RuntimeException { /* no details */}
 
diff --git a/jdt-patch/e421/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionOnAnnotationMemberValuePair.java b/jdt-patch/e421/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionOnAnnotationMemberValuePair.java
index 6e568bd946..06ffbcc5aa 100644
--- a/jdt-patch/e421/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionOnAnnotationMemberValuePair.java
+++ b/jdt-patch/e421/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionOnAnnotationMemberValuePair.java
@@ -13,10 +13,12 @@
  *******************************************************************************/
 package org.eclipse.jdt.internal.codeassist.complete;
 
+import org.eclipse.jdt.internal.compiler.ASTVisitor;
 import org.eclipse.jdt.internal.compiler.ast.MemberValuePair;
 import org.eclipse.jdt.internal.compiler.ast.NormalAnnotation;
 import org.eclipse.jdt.internal.compiler.ast.TypeReference;
 import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
+import org.eclipse.jdt.internal.compiler.lookup.ClassScope;
 import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
 
 public class CompletionOnAnnotationMemberValuePair extends NormalAnnotation {
@@ -57,4 +59,16 @@ public StringBuffer printExpression(int indent, StringBuffer output) {
 
 		return output;
 	}
+
+	@Override
+	public void traverse(ASTVisitor visitor, ClassScope scope) {
+		super.traverse(visitor, scope);
+		this.completedMemberValuePair.traverse(visitor, scope);
+	}
+
+	@Override
+	public void traverse(ASTVisitor visitor, BlockScope scope) {
+		super.traverse(visitor, scope);
+		this.completedMemberValuePair.traverse(visitor, scope);
+	}
 }
diff --git a/jdt-patch/e421/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionOnBreakStatement.java b/jdt-patch/e421/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionOnBreakStatement.java
new file mode 100644
index 0000000000..780c117fa4
--- /dev/null
+++ b/jdt-patch/e421/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionOnBreakStatement.java
@@ -0,0 +1,49 @@
+/*******************************************************************************
+ * Copyright (c) 2005, 2009 IBM Corporation 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:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jdt.internal.codeassist.complete;
+
+import org.eclipse.jdt.internal.compiler.ast.BreakStatement;
+import org.eclipse.jdt.internal.compiler.flow.FlowContext;
+import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
+import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
+
+public class CompletionOnBreakStatement extends BreakStatement {
+
+	public char[][] possibleLabels;
+
+	public CompletionOnBreakStatement(char[] l, int s, int e, char[][] possibleLabels) {
+		super(l, s, e);
+		this.possibleLabels = possibleLabels;
+	}
+
+	@Override
+	public FlowInfo analyseCode(BlockScope currentScope,
+			FlowContext flowContext, FlowInfo flowInfo) {
+		// Is never called
+		return null;
+	}
+
+	@Override
+	public void resolve(BlockScope scope) {
+		throw new CompletionNodeFound(this, scope);
+	}
+	@Override
+	public StringBuffer printStatement(int indent, StringBuffer output) {
+		printIndent(indent, output);
+		output.append("break "); //$NON-NLS-1$
+		output.append("<CompleteOnLabel:"); //$NON-NLS-1$
+		output.append(this.label);
+		return output.append(">;"); //$NON-NLS-1$
+	}
+}
diff --git a/jdt-patch/e421/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionOnContinueStatement.java b/jdt-patch/e421/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionOnContinueStatement.java
new file mode 100644
index 0000000000..5ebf7d42fb
--- /dev/null
+++ b/jdt-patch/e421/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionOnContinueStatement.java
@@ -0,0 +1,49 @@
+/*******************************************************************************
+ * Copyright (c) 2005, 2021 IBM Corporation 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:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jdt.internal.codeassist.complete;
+
+import org.eclipse.jdt.internal.compiler.ast.ContinueStatement;
+import org.eclipse.jdt.internal.compiler.flow.FlowContext;
+import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
+import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
+
+public class CompletionOnContinueStatement extends ContinueStatement {
+
+	public char[][] possibleLabels;
+
+	public CompletionOnContinueStatement(char[] l, int s, int e, char[][] possibleLabels) {
+		super(l, s, e);
+		this.possibleLabels = possibleLabels;
+	}
+
+	@Override
+	public FlowInfo analyseCode(BlockScope currentScope,
+			FlowContext flowContext, FlowInfo flowInfo) {
+		// Is never called
+		return null;
+	}
+
+	@Override
+	public void resolve(BlockScope scope) {
+		throw new CompletionNodeFound(this, scope);
+	}
+	@Override
+	public StringBuffer printStatement(int indent, StringBuffer output) {
+		printIndent(indent, output);
+		output.append("continue "); //$NON-NLS-1$
+		output.append("<CompleteOnLabel:"); //$NON-NLS-1$
+		output.append(this.label);
+		return output.append(">;"); //$NON-NLS-1$
+	}
+}
diff --git a/jdt-patch/e421/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionOnQualifiedTypeReference.java b/jdt-patch/e421/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionOnQualifiedTypeReference.java
index a6ca507669..4ab064be45 100644
--- a/jdt-patch/e421/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionOnQualifiedTypeReference.java
+++ b/jdt-patch/e421/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionOnQualifiedTypeReference.java
@@ -38,9 +38,10 @@ public class CompletionOnQualifiedTypeReference extends QualifiedTypeReference {
 
 	private int kind = K_TYPE;
 	public char[] completionIdentifier;
-	
+
 	public boolean isConstructorType;
-	
+	public int nextToken;
+
 public CompletionOnQualifiedTypeReference(char[][] previousIdentifiers, char[] completionIdentifier, long[] positions) {
 	this(previousIdentifiers, completionIdentifier, positions, K_TYPE);
 }
@@ -49,6 +50,10 @@ public CompletionOnQualifiedTypeReference(char[][] previousIdentifiers, char[] c
 	this.completionIdentifier = completionIdentifier;
 	this.kind = kind;
 }
+public CompletionOnQualifiedTypeReference(char[][] previousIdentifiers, char[] assistName, long[] positions, int kind, int nextToken) {
+	this(previousIdentifiers, assistName, positions, kind);
+	this.nextToken = nextToken;
+}
 @Override
 public void aboutToResolve(Scope scope) {
 	getTypeBinding(scope);
diff --git a/jdt-patch/e421/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionOnSingleTypeReference.java b/jdt-patch/e421/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionOnSingleTypeReference.java
index 4dc9c77d81..27eceba93f 100644
--- a/jdt-patch/e421/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionOnSingleTypeReference.java
+++ b/jdt-patch/e421/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionOnSingleTypeReference.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2012 IBM Corporation and others.
+ * Copyright (c) 2000, 2021 IBM Corporation and others.
  *
  * This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
@@ -40,6 +40,8 @@ public class CompletionOnSingleTypeReference extends SingleTypeReference {
 public boolean isCompletionNode;
 public boolean isConstructorType;
 public CompletionOnFieldType fieldTypeCompletionNode;
+public char[][] possibleKeywords;
+public boolean canBeExplicitConstructor;
 
 public CompletionOnSingleTypeReference(char[] source, long pos) {
 	this(source, pos, K_TYPE);
@@ -49,6 +51,11 @@ public CompletionOnSingleTypeReference(char[] source, long pos, int kind) {
 	this.isCompletionNode = true;
 	this.kind = kind;
 }
+public CompletionOnSingleTypeReference(char[] assistName, long position, char[][] keywords, boolean canBeSuperCall) {
+	this(assistName, position);
+	this.possibleKeywords = keywords;
+	this.canBeExplicitConstructor = canBeSuperCall;
+}
 @Override
 public void aboutToResolve(Scope scope) {
 	getTypeBinding(scope);
diff --git a/jdt-patch/e421/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionParser.java b/jdt-patch/e421/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionParser.java
index 277ea02711..4b4364a47b 100644
--- a/jdt-patch/e421/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionParser.java
+++ b/jdt-patch/e421/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionParser.java
@@ -18,6 +18,8 @@
  *******************************************************************************/
 package org.eclipse.jdt.internal.codeassist.complete;
 
+import java.util.ArrayList;
+
 /*
  * Parser able to build specific completion parse nodes, given a cursorLocation.
  *
@@ -29,6 +31,7 @@
  */
 
 import java.util.HashSet;
+import java.util.List;
 
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.jdt.core.compiler.CharOperation;
@@ -344,7 +347,7 @@ protected void detectAssistNodeParent(ASTNode node) {
 	CompletionNodeDetector detector = new CompletionNodeDetector(this.assistNode, node);
 	if (detector.containsCompletionNode()) {
 		this.assistNodeParent = detector.getCompletionNodeParent();
-		if (this.assistNodeParent == null && node instanceof Statement)
+		if (this.assistNodeParent == null && node instanceof Statement && node != this.assistNode)
 			this.assistNodeParent = node;
 	}
 }
@@ -1978,15 +1981,17 @@ private boolean checkLabelStatement() {
 		System.arraycopy(labels, 0, labels = new char[labelCount][], 0, labelCount);
 
 		long position = this.identifierPositionStack[this.identifierPtr];
-		CompletionOnBranchStatementLabel statementLabel =
-			new CompletionOnBranchStatementLabel(
-					kind == K_INSIDE_BREAK_STATEMENT ? CompletionOnBranchStatementLabel.BREAK : CompletionOnBranchStatementLabel.CONTINUE,
-					this.identifierStack[this.identifierPtr--],
-					(int) (position >>> 32),
-					(int)position,
-					labels);
-
-		this.assistNode = statementLabel;
+		this.assistNode = kind == K_INSIDE_BREAK_STATEMENT
+				? new CompletionOnBreakStatement(
+						this.identifierStack[this.identifierPtr--],
+						(int) (position >>> 32),
+						(int)position,
+						labels)
+				: new CompletionOnContinueStatement(
+						this.identifierStack[this.identifierPtr--],
+						(int) (position >>> 32),
+						(int)position,
+						labels);
 		this.lastCheckPoint = this.assistNode.sourceEnd + 1;
 		this.isOrphanCompletionNode = true;
 		return true;
@@ -5024,7 +5029,7 @@ private TypeReference checkAndCreateModuleQualifiedAssistTypeReference(char[][]
 		if (isAfterWithClause()) return new CompletionOnProvidesImplementationsQualifiedTypeReference(previousIdentifiers, assistName, positions);
 		return new CompletionOnProvidesInterfacesQualifiedTypeReference(previousIdentifiers, assistName, positions);
 	}
-	return new CompletionOnQualifiedTypeReference(previousIdentifiers,	assistName,	positions);
+	return null;
 }
 @Override
 public TypeReference createQualifiedAssistTypeReference(char[][] previousIdentifiers, char[] assistName, long[] positions){
@@ -5050,10 +5055,14 @@ public TypeReference createQualifiedAssistTypeReference(char[][] previousIdentif
 					positions,
 					CompletionOnQualifiedTypeReference.K_INTERFACE);
 		default :
-			return checkAndCreateModuleQualifiedAssistTypeReference(
+			TypeReference ref = checkAndCreateModuleQualifiedAssistTypeReference(
 					previousIdentifiers,
 					assistName,
 					positions);
+			if (ref != null)
+				return ref;
+			return new CompletionOnQualifiedTypeReference(previousIdentifiers, assistName, positions,
+					CompletionOnQualifiedTypeReference.K_TYPE, this.currentToken);
 	}
 }
 @Override
@@ -5128,120 +5137,123 @@ public NameReference createSingleAssistNameReference(char[] assistName, long pos
 			&& topKnownElementInfo(COMPLETION_OR_ASSIST_PARSER) == SWITCH) {
 			return new CompletionOnKeyword3(assistName, position, new char[][]{Keywords.CASE, Keywords.DEFAULT}, false);
 		} else {
-			char[][] keywords = new char[Keywords.COUNT][];
-			int count = 0;
+			List<char[]> keywordsList = new ArrayList<>(Keywords.COUNT);
+			canBeExplicitConstructorCall = computeKeywords(kind, keywordsList);
+			char[][] keywords = keywordsList.toArray(char[][]::new);
+			return new CompletionOnSingleNameReference(assistName, position, keywords, canBeExplicitConstructorCall, isInsideAttributeValue());
+		}
+	}
+}
+boolean computeKeywords(int kind, List<char[]> keywords) {
+	boolean canBeExplicitConstructorCall = false;
 
-			if((this.lastModifiers & ClassFileConstants.AccStatic) == 0) {
-				keywords[count++]= Keywords.SUPER;
-				keywords[count++]= Keywords.THIS;
-			}
-			keywords[count++]= Keywords.NEW;
-			// https://bugs.eclipse.org/bugs/show_bug.cgi?id=269493: Keywords are not proposed in a for
-			// loop without block. Completion while at K_CONTROL_STATEMENT_DELIMITER case needs to handled
-			// similar to the K_BLOCK_DELIMITER with minor differences.
-			if(kind == K_BLOCK_DELIMITER || kind == K_CONTROL_STATEMENT_DELIMITER || kind == K_LAMBDA_EXPRESSION_DELIMITER
-					|| kind == K_SWITCH_EXPRESSION_DELIMITTER) {
-				if(this.canBeExplicitConstructor == YES) {
-					canBeExplicitConstructorCall = true;
-				}
-				if (this.options.complianceLevel >= ClassFileConstants.JDK1_4) {
-					keywords[count++]= Keywords.ASSERT;
-				}
-				keywords[count++]= Keywords.DO;
-				keywords[count++]= Keywords.FOR;
-				keywords[count++]= Keywords.IF;
-				keywords[count++]= Keywords.RETURN;
-				keywords[count++]= Keywords.SWITCH;
-				keywords[count++]= Keywords.SYNCHRONIZED;
-				keywords[count++]= Keywords.THROW;
-				keywords[count++]= Keywords.TRY;
-				keywords[count++]= Keywords.WHILE;
-
-				keywords[count++]= Keywords.FINAL;
-				keywords[count++]= Keywords.CLASS;
-				if (this.options.complianceLevel >= ClassFileConstants.JDK10) {
-					keywords[count++]= Keywords.VAR;
-				}
-				if (this.options.complianceLevel >= ClassFileConstants.JDK16) {
-					keywords[count++]= Keywords.INTERFACE;
-					keywords[count++]= Keywords.ENUM;
-				}
+	if((this.lastModifiers & ClassFileConstants.AccStatic) == 0) {
+		keywords.add(Keywords.SUPER);
+		keywords.add(Keywords.THIS);
+	}
+	keywords.add(Keywords.NEW);
+	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=269493: Keywords are not proposed in a for
+	// loop without block. Completion while at K_CONTROL_STATEMENT_DELIMITER case needs to handled
+	// similar to the K_BLOCK_DELIMITER with minor differences.
+	if(kind == K_BLOCK_DELIMITER || kind == K_CONTROL_STATEMENT_DELIMITER || kind == K_LAMBDA_EXPRESSION_DELIMITER
+			|| kind == K_SWITCH_EXPRESSION_DELIMITTER) {
+		if(this.canBeExplicitConstructor == YES) {
+			canBeExplicitConstructorCall = true;
+		}
+		if (this.options.complianceLevel >= ClassFileConstants.JDK1_4) {
+			keywords.add(Keywords.ASSERT);
+		}
+		keywords.add(Keywords.DO);
+		keywords.add(Keywords.FOR);
+		keywords.add(Keywords.IF);
+		keywords.add(Keywords.RETURN);
+		keywords.add(Keywords.SWITCH);
+		keywords.add(Keywords.SYNCHRONIZED);
+		keywords.add(Keywords.THROW);
+		keywords.add(Keywords.TRY);
+		keywords.add(Keywords.WHILE);
 
-				if(this.previousKind == K_BLOCK_DELIMITER) {
-					switch (this.previousInfo) {
-						case IF :
-							keywords[count++]= Keywords.ELSE;
-							break;
-						case CATCH :
-							keywords[count++]= Keywords.CATCH;
-							keywords[count++]= Keywords.FINALLY;
-							break;
-					}
-				} else if(this.previousKind == K_CONTROL_STATEMENT_DELIMITER && this.previousInfo == IF) {
-					keywords[count++]= Keywords.ELSE;
-				}
-				if(isInsideLoop()) {
-					keywords[count++]= Keywords.CONTINUE;
-				}
-				if(isInsideBreakable()) {
-					keywords[count++]= Keywords.BREAK;
-				}
-				if(isInsideSwitch()) {
-					keywords[count++]= Keywords.YIELD;
-				}
-			} else if (kind == K_BETWEEN_FOR_AND_RIGHT_PAREN) {
-				if (this.options.complianceLevel >= ClassFileConstants.JDK10) {
-					keywords[count++]= Keywords.VAR;
-				}
-			} else if(kind != K_BETWEEN_CASE_AND_COLON && kind != K_BETWEEN_DEFAULT_AND_COLON) {
-				if (kind == K_LOCAL_INITIALIZER_DELIMITER && this.options.complianceLevel >= ClassFileConstants.JDK11) {
-					keywords[count++]= Keywords.VAR;
-				}
-				if (kind == K_SELECTOR_QUALIFIER && this.options.complianceLevel >= ClassFileConstants.JDK12) {
-					keywords[count++] = Keywords.SWITCH;
-				}
-				keywords[count++]= Keywords.TRUE;
-				keywords[count++]= Keywords.FALSE;
-				keywords[count++]= Keywords.NULL;
-				if (kind == K_YIELD_KEYWORD) {
-					keywords[count++]= Keywords.YIELD;
-				}
-				if(kind == K_SWITCH_LABEL) {
-					if(topKnownElementInfo(COMPLETION_OR_ASSIST_PARSER) != DEFAULT) {
-						keywords[count++]= Keywords.DEFAULT;
-					}
-					keywords[count++]= Keywords.BREAK;
-					keywords[count++]= Keywords.CASE;
-					keywords[count++]= Keywords.YIELD;
-					if (this.options.complianceLevel >= ClassFileConstants.JDK1_4) {
-						keywords[count++]= Keywords.ASSERT;
-					}
-					keywords[count++]= Keywords.DO;
-					keywords[count++]= Keywords.FOR;
-					keywords[count++]= Keywords.IF;
-					keywords[count++]= Keywords.RETURN;
-					keywords[count++]= Keywords.SWITCH;
-					keywords[count++]= Keywords.SYNCHRONIZED;
-					keywords[count++]= Keywords.THROW;
-					keywords[count++]= Keywords.TRY;
-					keywords[count++]= Keywords.WHILE;
-
-					keywords[count++]= Keywords.FINAL;
-					keywords[count++]= Keywords.CLASS;
-
-					if (this.options.complianceLevel >= ClassFileConstants.JDK10) {
-						keywords[count++]= Keywords.VAR;
-					}
-					if(isInsideLoop()) {
-						keywords[count++]= Keywords.CONTINUE;
-					}
-				}
-			}
-			System.arraycopy(keywords, 0 , keywords = new char[count][], 0, count);
+		keywords.add(Keywords.FINAL);
+		keywords.add(Keywords.CLASS);
+		if (this.options.complianceLevel >= ClassFileConstants.JDK10) {
+			keywords.add(Keywords.VAR);
+		}
+		if (this.options.complianceLevel >= ClassFileConstants.JDK16) {
+			keywords.add(Keywords.INTERFACE);
+			keywords.add(Keywords.ENUM);
+		}
 
-			return new CompletionOnSingleNameReference(assistName, position, keywords, canBeExplicitConstructorCall, isInsideAttributeValue());
+		if(this.previousKind == K_BLOCK_DELIMITER) {
+			switch (this.previousInfo) {
+				case IF :
+					keywords.add(Keywords.ELSE);
+					break;
+				case CATCH :
+					keywords.add(Keywords.CATCH);
+					keywords.add(Keywords.FINALLY);
+					break;
+			}
+		} else if(this.previousKind == K_CONTROL_STATEMENT_DELIMITER && this.previousInfo == IF) {
+			keywords.add(Keywords.ELSE);
+		}
+		if(isInsideLoop()) {
+			keywords.add(Keywords.CONTINUE);
+		}
+		if(isInsideBreakable()) {
+			keywords.add(Keywords.BREAK);
+		}
+		if(isInsideSwitch()) {
+			keywords.add(Keywords.YIELD);
+		}
+	} else if (kind == K_BETWEEN_FOR_AND_RIGHT_PAREN) {
+		if (this.options.complianceLevel >= ClassFileConstants.JDK10) {
+			keywords.add(Keywords.VAR);
+		}
+	} else if(kind != K_BETWEEN_CASE_AND_COLON && kind != K_BETWEEN_DEFAULT_AND_COLON) {
+		if (kind == K_LOCAL_INITIALIZER_DELIMITER && this.options.complianceLevel >= ClassFileConstants.JDK11) {
+			keywords.add(Keywords.VAR);
+		}
+		if (kind == K_SELECTOR_QUALIFIER && this.options.complianceLevel >= ClassFileConstants.JDK12) {
+			keywords.add(Keywords.SWITCH);
+		}
+		keywords.add(Keywords.TRUE);
+		keywords.add(Keywords.FALSE);
+		keywords.add(Keywords.NULL);
+		if (kind == K_YIELD_KEYWORD) {
+			keywords.add(Keywords.YIELD);
+		}
+		if(kind == K_SWITCH_LABEL) {
+			if(topKnownElementInfo(COMPLETION_OR_ASSIST_PARSER) != DEFAULT) {
+				keywords.add(Keywords.DEFAULT);
+			}
+			keywords.add(Keywords.BREAK);
+			keywords.add(Keywords.CASE);
+			keywords.add(Keywords.YIELD);
+			if (this.options.complianceLevel >= ClassFileConstants.JDK1_4) {
+				keywords.add(Keywords.ASSERT);
+			}
+			keywords.add(Keywords.DO);
+			keywords.add(Keywords.FOR);
+			keywords.add(Keywords.IF);
+			keywords.add(Keywords.RETURN);
+			keywords.add(Keywords.SWITCH);
+			keywords.add(Keywords.SYNCHRONIZED);
+			keywords.add(Keywords.THROW);
+			keywords.add(Keywords.TRY);
+			keywords.add(Keywords.WHILE);
+
+			keywords.add(Keywords.FINAL);
+			keywords.add(Keywords.CLASS);
+
+			if (this.options.complianceLevel >= ClassFileConstants.JDK10) {
+				keywords.add(Keywords.VAR);
+			}
+			if(isInsideLoop()) {
+				keywords.add(Keywords.CONTINUE);
+			}
 		}
 	}
+	return canBeExplicitConstructorCall;
 }
 private TypeReference checkAndCreateModuleSingleAssistTypeReference(char[] assistName, long position) {
 	if (isInUsesStatement()) return new CompletionOnUsesSingleTypeReference(assistName, position);
@@ -5249,7 +5261,9 @@ private TypeReference checkAndCreateModuleSingleAssistTypeReference(char[] assis
 		if (isAfterWithClause()) return new CompletionOnProvidesImplementationsSingleTypeReference(assistName, position);
 		return new CompletionOnProvidesInterfacesSingleTypeReference(assistName, position);
 	}
-	return new CompletionOnSingleTypeReference(assistName,position);
+	List<char[]> keywords = new ArrayList<>(Keywords.COUNT);
+	boolean canBeCtorCall = computeKeywords(topKnownElementKind(COMPLETION_OR_ASSIST_PARSER), keywords);
+	return new CompletionOnSingleTypeReference(assistName,position, keywords.toArray(char[][]::new), canBeCtorCall);
 }
 @Override
 public TypeReference createSingleAssistTypeReference(char[] assistName, long position) {
@@ -5458,6 +5472,14 @@ protected NameReference getUnspecifiedReference(boolean rejectTypeAnnotations) {
 	return ref;
 }
 @Override
+protected void updateSourcePosition(Expression exp) {
+	// handles total positions of parenthesized expressions, but don't extend position of the assist node:
+	if (exp == this.assistNode)
+		this.intPtr -= 2;
+	else
+		super.updateSourcePosition(exp);
+}
+@Override
 protected void consumePostfixExpression() {
 	// PostfixExpression ::= Name
 	if (topKnownElementKind(COMPLETION_OR_ASSIST_PARSER) != K_YIELD_KEYWORD) {
@@ -6121,7 +6143,6 @@ protected void updateRecoveryState() {
 
 	recoveryExitFromVariable();
 }
-
 @Override
 protected CompilationUnitDeclaration endParse(int act) {
 	CompilationUnitDeclaration cud = super.endParse(act);
@@ -6141,10 +6162,23 @@ protected CompilationUnitDeclaration endParse(int act) {
 				statement = (Statement) this.assistNode;
 			}
 			AbstractMethodDeclaration method = (AbstractMethodDeclaration) this.referenceContext;
-			if (statement != null && isInsideBody(statement, method)) {
+			if (statement != null && isInsideBody(statement, method)
+					&& this.assistNode != null && !CompletionNodeDetector.findAny(cud, this.assistNode))
+			{
 				// automaton ended right before transferring statements into the method?
 				if (method.statements == null) {
 					method.statements = new Statement[] { statement };
+				} else if (this.currentElement != null) {
+					// or before transferring statements into a nested recovered element?
+					this.currentElement.add(statement, 0);
+					RecoveredElement element = this.currentElement;
+					while (element != null) {
+						if (element instanceof RecoveredMethod && ((RecoveredMethod) element).methodDeclaration == method) {
+							element.updateParseTree();
+							break;
+						}
+						element = element.parent;
+					}
 				}
 			}
 		}
diff --git a/jdt-patch/e421/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/GenericAstVisitor.java b/jdt-patch/e421/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/GenericAstVisitor.java
new file mode 100644
index 0000000000..eb8f6df1c9
--- /dev/null
+++ b/jdt-patch/e421/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/GenericAstVisitor.java
@@ -0,0 +1,711 @@
+/*******************************************************************************
+ * Copyright (c) 2021 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.internal.compiler;
+
+import org.eclipse.jdt.internal.compiler.ast.*;
+import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
+import org.eclipse.jdt.internal.compiler.lookup.ClassScope;
+import org.eclipse.jdt.internal.compiler.lookup.CompilationUnitScope;
+import org.eclipse.jdt.internal.compiler.lookup.MethodScope;
+
+public abstract class GenericAstVisitor extends ASTVisitor {
+
+	// override this to handle all nodes:
+	protected abstract boolean visitNode(ASTNode node);
+
+	@Override
+	public boolean visit(AllocationExpression allocationExpression, BlockScope scope) {
+		return visitNode(allocationExpression);
+	}
+
+	@Override
+	public boolean visit(AND_AND_Expression and_and_Expression, BlockScope scope) {
+		return visitNode(and_and_Expression);
+	}
+
+	@Override
+	public boolean visit(AnnotationMethodDeclaration annotationTypeDeclaration, ClassScope classScope) {
+		return visitNode(annotationTypeDeclaration);
+	}
+
+	@Override
+	public boolean visit(Argument argument, BlockScope scope) {
+		return visitNode(argument);
+	}
+
+	@Override
+	public boolean visit(Argument argument, ClassScope scope) {
+		return visitNode(argument);
+	}
+
+	@Override
+	public boolean visit(ArrayAllocationExpression arrayAllocationExpression, BlockScope scope) {
+		return visitNode(arrayAllocationExpression);
+	}
+
+	@Override
+	public boolean visit(ArrayInitializer arrayInitializer, BlockScope scope) {
+		return visitNode(arrayInitializer);
+	}
+
+	@Override
+	public boolean visit(ArrayInitializer arrayInitializer, ClassScope scope) {
+		return visitNode(arrayInitializer);
+	}
+
+	@Override
+	public boolean visit(ArrayQualifiedTypeReference arrayQualifiedTypeReference, BlockScope scope) {
+		return visitNode(arrayQualifiedTypeReference);
+	}
+
+	@Override
+	public boolean visit(ArrayQualifiedTypeReference arrayQualifiedTypeReference, ClassScope scope) {
+		return visitNode(arrayQualifiedTypeReference);
+	}
+
+	@Override
+	public boolean visit(ArrayReference arrayReference, BlockScope scope) {
+		return visitNode(arrayReference);
+	}
+
+	@Override
+	public boolean visit(ArrayTypeReference arrayTypeReference, BlockScope scope) {
+		return visitNode(arrayTypeReference);
+	}
+
+	@Override
+	public boolean visit(ArrayTypeReference arrayTypeReference, ClassScope scope) {
+		return visitNode(arrayTypeReference);
+	}
+
+	@Override
+	public boolean visit(AssertStatement assertStatement, BlockScope scope) {
+		return visitNode(assertStatement);
+	}
+
+	@Override
+	public boolean visit(Assignment assignment, BlockScope scope) {
+		return visitNode(assignment);
+	}
+
+	@Override
+	public boolean visit(BinaryExpression binaryExpression, BlockScope scope) {
+		return visitNode(binaryExpression);
+	}
+
+	@Override
+	public boolean visit(Block block, BlockScope scope) {
+		return visitNode(block);
+	}
+
+	@Override
+	public boolean visit(BreakStatement breakStatement, BlockScope scope) {
+		return visitNode(breakStatement);
+	}
+
+	@Override
+	public boolean visit(CaseStatement caseStatement, BlockScope scope) {
+		return visitNode(caseStatement);
+	}
+
+	@Override
+	public boolean visit(CastExpression castExpression, BlockScope scope) {
+		return visitNode(castExpression);
+	}
+
+	@Override
+	public boolean visit(CharLiteral charLiteral, BlockScope scope) {
+		return visitNode(charLiteral);
+	}
+
+	@Override
+	public boolean visit(ClassLiteralAccess classLiteral, BlockScope scope) {
+		return visitNode(classLiteral);
+	}
+
+	@Override
+	public boolean visit(Clinit clinit, ClassScope scope) {
+		return visitNode(clinit);
+	}
+
+	@Override
+	public boolean visit(ModuleDeclaration module, CompilationUnitScope scope) {
+		return visitNode(module);
+	}
+
+	@Override
+	public boolean visit(CompactConstructorDeclaration ccd, ClassScope scope) {
+		return visitNode(ccd);
+	}
+
+	@Override
+	public boolean visit(CompilationUnitDeclaration compilationUnitDeclaration, CompilationUnitScope scope) {
+		return visitNode(compilationUnitDeclaration);
+	}
+
+	@Override
+	public boolean visit(CompoundAssignment compoundAssignment, BlockScope scope) {
+		return visitNode(compoundAssignment);
+	}
+
+	@Override
+	public boolean visit(ConditionalExpression conditionalExpression, BlockScope scope) {
+		return visitNode(conditionalExpression);
+	}
+
+	@Override
+	public boolean visit(ConstructorDeclaration constructorDeclaration, ClassScope scope) {
+		return visitNode(constructorDeclaration);
+	}
+
+	@Override
+	public boolean visit(ContinueStatement continueStatement, BlockScope scope) {
+		return visitNode(continueStatement);
+	}
+
+	@Override
+	public boolean visit(DoStatement doStatement, BlockScope scope) {
+		return visitNode(doStatement);
+	}
+
+	@Override
+	public boolean visit(DoubleLiteral doubleLiteral, BlockScope scope) {
+		return visitNode(doubleLiteral);
+	}
+
+	@Override
+	public boolean visit(EmptyStatement emptyStatement, BlockScope scope) {
+		return visitNode(emptyStatement);
+	}
+
+	@Override
+	public boolean visit(EqualExpression equalExpression, BlockScope scope) {
+		return visitNode(equalExpression);
+	}
+
+	@Override
+	public boolean visit(ExplicitConstructorCall explicitConstructor, BlockScope scope) {
+		return visitNode(explicitConstructor);
+	}
+
+	@Override
+	public boolean visit(ExtendedStringLiteral extendedStringLiteral, BlockScope scope) {
+		return visitNode(extendedStringLiteral);
+	}
+
+	@Override
+	public boolean visit(FalseLiteral falseLiteral, BlockScope scope) {
+		return visitNode(falseLiteral);
+	}
+
+	@Override
+	public boolean visit(FieldDeclaration fieldDeclaration, MethodScope scope) {
+		return visitNode(fieldDeclaration);
+	}
+
+	@Override
+	public boolean visit(FieldReference fieldReference, BlockScope scope) {
+		return visitNode(fieldReference);
+	}
+
+	@Override
+	public boolean visit(FieldReference fieldReference, ClassScope scope) {
+		return visitNode(fieldReference);
+	}
+
+	@Override
+	public boolean visit(FloatLiteral floatLiteral, BlockScope scope) {
+		return visitNode(floatLiteral);
+	}
+
+	@Override
+	public boolean visit(ForeachStatement forStatement, BlockScope scope) {
+		return visitNode(forStatement);
+	}
+
+	@Override
+	public boolean visit(ForStatement forStatement, BlockScope scope) {
+		return visitNode(forStatement);
+	}
+
+	@Override
+	public boolean visit(IfStatement ifStatement, BlockScope scope) {
+		return visitNode(ifStatement);
+	}
+
+	@Override
+	public boolean visit(ImportReference importRef, CompilationUnitScope scope) {
+		return visitNode(importRef);
+	}
+
+	@Override
+	public boolean visit(Initializer initializer, MethodScope scope) {
+		return visitNode(initializer);
+	}
+
+	@Override
+	public boolean visit(InstanceOfExpression instanceOfExpression, BlockScope scope) {
+		return visitNode(instanceOfExpression);
+	}
+
+	@Override
+	public boolean visit(IntLiteral intLiteral, BlockScope scope) {
+		return visitNode(intLiteral);
+	}
+
+	@Override
+	public boolean visit(Javadoc javadoc, BlockScope scope) {
+		return visitNode(javadoc);
+	}
+
+	@Override
+	public boolean visit(Javadoc javadoc, ClassScope scope) {
+		return visitNode(javadoc);
+	}
+
+	@Override
+	public boolean visit(JavadocAllocationExpression expression, BlockScope scope) {
+		return visitNode(expression);
+	}
+
+	@Override
+	public boolean visit(JavadocAllocationExpression expression, ClassScope scope) {
+		return visitNode(expression);
+	}
+
+	@Override
+	public boolean visit(JavadocArgumentExpression expression, BlockScope scope) {
+		return visitNode(expression);
+	}
+
+	@Override
+	public boolean visit(JavadocArgumentExpression expression, ClassScope scope) {
+		return visitNode(expression);
+	}
+
+	@Override
+	public boolean visit(JavadocArrayQualifiedTypeReference typeRef, BlockScope scope) {
+		return visitNode(typeRef);
+	}
+
+	@Override
+	public boolean visit(JavadocArrayQualifiedTypeReference typeRef, ClassScope scope) {
+		return visitNode(typeRef);
+	}
+
+	@Override
+	public boolean visit(JavadocArraySingleTypeReference typeRef, BlockScope scope) {
+		return visitNode(typeRef);
+	}
+
+	@Override
+	public boolean visit(JavadocArraySingleTypeReference typeRef, ClassScope scope) {
+		return visitNode(typeRef);
+	}
+
+	@Override
+	public boolean visit(JavadocFieldReference fieldRef, BlockScope scope) {
+		return visitNode(fieldRef);
+	}
+
+	@Override
+	public boolean visit(JavadocFieldReference fieldRef, ClassScope scope) {
+		return visitNode(fieldRef);
+	}
+
+	@Override
+	public boolean visit(JavadocImplicitTypeReference implicitTypeReference, BlockScope scope) {
+		return visitNode(implicitTypeReference);
+	}
+
+	@Override
+	public boolean visit(JavadocImplicitTypeReference implicitTypeReference, ClassScope scope) {
+		return visitNode(implicitTypeReference);
+	}
+
+	@Override
+	public boolean visit(JavadocMessageSend messageSend, BlockScope scope) {
+		return visitNode(messageSend);
+	}
+
+	@Override
+	public boolean visit(JavadocMessageSend messageSend, ClassScope scope) {
+		return visitNode(messageSend);
+	}
+
+	@Override
+	public boolean visit(JavadocQualifiedTypeReference typeRef, BlockScope scope) {
+		return visitNode(typeRef);
+	}
+
+	@Override
+	public boolean visit(JavadocQualifiedTypeReference typeRef, ClassScope scope) {
+		return visitNode(typeRef);
+	}
+
+	@Override
+	public boolean visit(JavadocModuleReference moduleRef, BlockScope scope) {
+		return visitNode(moduleRef);
+	}
+
+	@Override
+	public boolean visit(JavadocModuleReference moduleRef, ClassScope scope) {
+		return visitNode(moduleRef);
+	}
+
+	@Override
+	public boolean visit(JavadocReturnStatement statement, BlockScope scope) {
+		return visitNode(statement);
+	}
+
+	@Override
+	public boolean visit(JavadocReturnStatement statement, ClassScope scope) {
+		return visitNode(statement);
+	}
+
+	@Override
+	public boolean visit(JavadocSingleNameReference argument, BlockScope scope) {
+		return visitNode(argument);
+	}
+
+	@Override
+	public boolean visit(JavadocSingleNameReference argument, ClassScope scope) {
+		return visitNode(argument);
+	}
+
+	@Override
+	public boolean visit(JavadocSingleTypeReference typeRef, BlockScope scope) {
+		return visitNode(typeRef);
+	}
+
+	@Override
+	public boolean visit(JavadocSingleTypeReference typeRef, ClassScope scope) {
+		return visitNode(typeRef);
+	}
+
+	@Override
+	public boolean visit(LabeledStatement labeledStatement, BlockScope scope) {
+		return visitNode(labeledStatement);
+	}
+
+	@Override
+	public boolean visit(LocalDeclaration localDeclaration, BlockScope scope) {
+		return visitNode(localDeclaration);
+	}
+
+	@Override
+	public boolean visit(LongLiteral longLiteral, BlockScope scope) {
+		return visitNode(longLiteral);
+	}
+
+	@Override
+	public boolean visit(MarkerAnnotation annotation, BlockScope scope) {
+		return visitNode(annotation);
+	}
+
+	@Override
+	public boolean visit(MarkerAnnotation annotation, ClassScope scope) {
+		return visitNode(annotation);
+	}
+
+	@Override
+	public boolean visit(MemberValuePair pair, BlockScope scope) {
+		return visitNode(pair);
+	}
+
+	@Override
+	public boolean visit(MemberValuePair pair, ClassScope scope) {
+		return visitNode(pair);
+	}
+
+	@Override
+	public boolean visit(MessageSend messageSend, BlockScope scope) {
+		return visitNode(messageSend);
+	}
+
+	@Override
+	public boolean visit(MethodDeclaration methodDeclaration, ClassScope scope) {
+		return visitNode(methodDeclaration);
+	}
+
+	@Override
+	public boolean visit(StringLiteralConcatenation literal, BlockScope scope) {
+		return visitNode(literal);
+	}
+
+	@Override
+	public boolean visit(NormalAnnotation annotation, BlockScope scope) {
+		return visitNode(annotation);
+	}
+
+	@Override
+	public boolean visit(NormalAnnotation annotation, ClassScope scope) {
+		return visitNode(annotation);
+	}
+
+	@Override
+	public boolean visit(NullLiteral nullLiteral, BlockScope scope) {
+		return visitNode(nullLiteral);
+	}
+
+	@Override
+	public boolean visit(OR_OR_Expression or_or_Expression, BlockScope scope) {
+		return visitNode(or_or_Expression);
+	}
+
+	@Override
+	public boolean visit(ParameterizedQualifiedTypeReference parameterizedQualifiedTypeReference, BlockScope scope) {
+		return visitNode(parameterizedQualifiedTypeReference);
+	}
+
+	@Override
+	public boolean visit(ParameterizedQualifiedTypeReference parameterizedQualifiedTypeReference, ClassScope scope) {
+		return visitNode(parameterizedQualifiedTypeReference);
+	}
+
+	@Override
+	public boolean visit(ParameterizedSingleTypeReference parameterizedSingleTypeReference, BlockScope scope) {
+		return visitNode(parameterizedSingleTypeReference);
+	}
+
+	@Override
+	public boolean visit(ParameterizedSingleTypeReference parameterizedSingleTypeReference, ClassScope scope) {
+		return visitNode(parameterizedSingleTypeReference);
+	}
+
+	@Override
+	public boolean visit(PostfixExpression postfixExpression, BlockScope scope) {
+		return visitNode(postfixExpression);
+	}
+
+	@Override
+	public boolean visit(PrefixExpression prefixExpression, BlockScope scope) {
+		return visitNode(prefixExpression);
+	}
+
+	@Override
+	public boolean visit(QualifiedAllocationExpression qualifiedAllocationExpression, BlockScope scope) {
+		return visitNode(qualifiedAllocationExpression);
+	}
+
+	@Override
+	public boolean visit(QualifiedNameReference qualifiedNameReference, BlockScope scope) {
+		return visitNode(qualifiedNameReference);
+	}
+
+	@Override
+	public boolean visit(QualifiedNameReference qualifiedNameReference, ClassScope scope) {
+		return visitNode(qualifiedNameReference);
+	}
+
+	@Override
+	public boolean visit(QualifiedSuperReference qualifiedSuperReference, BlockScope scope) {
+		return visitNode(qualifiedSuperReference);
+	}
+
+	@Override
+	public boolean visit(QualifiedSuperReference qualifiedSuperReference, ClassScope scope) {
+		return visitNode(qualifiedSuperReference);
+	}
+
+	@Override
+	public boolean visit(QualifiedThisReference qualifiedThisReference, BlockScope scope) {
+		return visitNode(qualifiedThisReference);
+	}
+
+	@Override
+	public boolean visit(QualifiedThisReference qualifiedThisReference, ClassScope scope) {
+		return visitNode(qualifiedThisReference);
+	}
+
+	@Override
+	public boolean visit(QualifiedTypeReference qualifiedTypeReference, BlockScope scope) {
+		return visitNode(qualifiedTypeReference);
+	}
+
+	@Override
+	public boolean visit(QualifiedTypeReference qualifiedTypeReference, ClassScope scope) {
+		return visitNode(qualifiedTypeReference);
+	}
+
+	@Override
+	public boolean visit(ReturnStatement returnStatement, BlockScope scope) {
+		return visitNode(returnStatement);
+	}
+
+	@Override
+	public boolean visit(SingleMemberAnnotation annotation, BlockScope scope) {
+		return visitNode(annotation);
+	}
+
+	@Override
+	public boolean visit(SingleMemberAnnotation annotation, ClassScope scope) {
+		return visitNode(annotation);
+	}
+
+	@Override
+	public boolean visit(SingleNameReference singleNameReference, BlockScope scope) {
+		return visitNode(singleNameReference);
+	}
+
+	@Override
+	public boolean visit(SingleNameReference singleNameReference, ClassScope scope) {
+		return visitNode(singleNameReference);
+	}
+
+	@Override
+	public boolean visit(SingleTypeReference singleTypeReference, BlockScope scope) {
+		return visitNode(singleTypeReference);
+	}
+
+	@Override
+	public boolean visit(SingleTypeReference singleTypeReference, ClassScope scope) {
+		return visitNode(singleTypeReference);
+	}
+
+	@Override
+	public boolean visit(StringLiteral stringLiteral, BlockScope scope) {
+		return visitNode(stringLiteral);
+	}
+
+	@Override
+	public boolean visit(SuperReference superReference, BlockScope scope) {
+		return visitNode(superReference);
+	}
+
+	@Override
+	public boolean visit(SwitchStatement switchStatement, BlockScope scope) {
+		return visitNode(switchStatement);
+	}
+
+	@Override
+	public boolean visit(SynchronizedStatement synchronizedStatement, BlockScope scope) {
+		return visitNode(synchronizedStatement);
+	}
+
+	@Override
+	public boolean visit(ThisReference thisReference, BlockScope scope) {
+		return visitNode(thisReference);
+	}
+
+	@Override
+	public boolean visit(ThisReference thisReference, ClassScope scope) {
+		return visitNode(thisReference);
+	}
+
+	@Override
+	public boolean visit(ThrowStatement throwStatement, BlockScope scope) {
+		return visitNode(throwStatement);
+	}
+
+	@Override
+	public boolean visit(TrueLiteral trueLiteral, BlockScope scope) {
+		return visitNode(trueLiteral);
+	}
+
+	@Override
+	public boolean visit(TryStatement tryStatement, BlockScope scope) {
+		return visitNode(tryStatement);
+	}
+
+	@Override
+	public boolean visit(TypeDeclaration localTypeDeclaration, BlockScope scope) {
+		return visitNode(localTypeDeclaration);
+	}
+
+	@Override
+	public boolean visit(TypeDeclaration memberTypeDeclaration, ClassScope scope) {
+		return visitNode(memberTypeDeclaration);
+	}
+
+	@Override
+	public boolean visit(TypeDeclaration typeDeclaration, CompilationUnitScope scope) {
+		return visitNode(typeDeclaration);
+	}
+
+	@Override
+	public boolean visit(TypeParameter typeParameter, BlockScope scope) {
+		return visitNode(typeParameter);
+	}
+
+	@Override
+	public boolean visit(TypeParameter typeParameter, ClassScope scope) {
+		return visitNode(typeParameter);
+	}
+
+	@Override
+	public boolean visit(UnaryExpression unaryExpression, BlockScope scope) {
+		return visitNode(unaryExpression);
+	}
+
+	@Override
+	public boolean visit(UnionTypeReference unionTypeReference, BlockScope scope) {
+		return visitNode(unionTypeReference);
+	}
+
+	@Override
+	public boolean visit(UnionTypeReference unionTypeReference, ClassScope scope) {
+		return visitNode(unionTypeReference);
+	}
+
+	@Override
+	public boolean visit(YieldStatement yieldStatement, BlockScope scope) {
+		return visitNode(yieldStatement);
+	}
+
+	@Override
+	public boolean visit(WhileStatement whileStatement, BlockScope scope) {
+		return visitNode(whileStatement);
+	}
+
+	@Override
+	public boolean visit(Wildcard wildcard, BlockScope scope) {
+		return visitNode(wildcard);
+	}
+
+	@Override
+	public boolean visit(Wildcard wildcard, ClassScope scope) {
+		return visitNode(wildcard);
+	}
+
+	@Override
+	public boolean visit(LambdaExpression lambdaExpression, BlockScope blockScope) {
+		return visitNode(lambdaExpression);
+	}
+
+	@Override
+	public boolean visit(ReferenceExpression referenceExpression, BlockScope blockScope) {
+		return visitNode(referenceExpression);
+	}
+
+	@Override
+	public boolean visit(IntersectionCastTypeReference intersectionCastTypeReference, ClassScope scope) {
+		return visitNode(intersectionCastTypeReference);
+	}
+
+	@Override
+	public boolean visit(IntersectionCastTypeReference intersectionCastTypeReference, BlockScope scope) {
+		return visitNode(intersectionCastTypeReference);
+	}
+
+	@Override
+	public boolean visit(SwitchExpression switchExpression, BlockScope blockScope) {
+		return visitNode(switchExpression);
+	}
+
+	@Override
+	public boolean visit(RecordComponent recordComponent, BlockScope scope) {
+		return visitNode(recordComponent);
+	}
+}
diff --git a/jdt-patch/e421/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/Parser.java b/jdt-patch/e421/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/Parser.java
index ed3a5dc19c..7ff95fcf0d 100644
--- a/jdt-patch/e421/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/Parser.java
+++ b/jdt-patch/e421/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/Parser.java
@@ -4562,6 +4562,9 @@ private LocalDeclaration getInstanceOfVar(TypeReference type) {
 	this.identifierLengthPtr--;
 
 	local.declarationSourceStart = type.sourceStart;
+	// Move annotations from type reference to LocalDeclaration
+	local.annotations = type.annotations != null && type.annotations.length > 0 ? type.annotations[0] : null;
+	type.annotations = null;
 	local.type = type;
 	problemReporter().validateJavaFeatureSupport(JavaFeature.PATTERN_MATCHING_IN_INSTANCEOF, type.sourceStart, local.declarationEnd);
 	local.modifiers |= ClassFileConstants.AccFinal;
diff --git a/jdt-patch/e421/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTNode.java b/jdt-patch/e421/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTNode.java
index 7c30e69e92..24f2ba75aa 100644
--- a/jdt-patch/e421/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTNode.java
+++ b/jdt-patch/e421/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTNode.java
@@ -987,15 +987,6 @@ public abstract class ASTNode {
 	 */
 	public static final int RECORD_DECLARATION = 103;
 
-
-	/**
-	 * Node type constant indicating a node of type
-	 * <code>ModuleQualifiedName</code>.
-	 * @see ModuleQualifiedName
-	 * @since 3.24
-	 */
-	public static final int MODULE_QUALIFIED_NAME = 103;
-
 	/**
 	 * Node type constant indicating a node of type
 	 * <code>PatternInstanceofExpression</code>.
@@ -1004,6 +995,14 @@ public abstract class ASTNode {
 	 */
 	public static final int PATTERN_INSTANCEOF_EXPRESSION = 104;
 
+	/**
+	 * Node type constant indicating a node of type
+	 * <code>ModuleQualifiedName</code>.
+	 * @see ModuleQualifiedName
+	 * @since 3.24
+	 */
+	public static final int MODULE_QUALIFIED_NAME = 105;
+
 	/**
 	 * Returns the node class for the corresponding node type.
 	 *
@@ -1124,6 +1123,8 @@ public static Class nodeClassForType(int nodeType) {
 				return ModuleDeclaration.class;
 			case MODULE_MODIFIER :
 				return ModuleModifier.class;
+			case MODULE_QUALIFIED_NAME :
+				return ModuleQualifiedName.class;
 			case NAME_QUALIFIED_TYPE :
 				return NameQualifiedType.class;
 			case NORMAL_ANNOTATION :
diff --git a/jdt-patch/e421/org.eclipse.jdt.core/model/org/eclipse/jdt/core/JavaCore.java b/jdt-patch/e421/org.eclipse.jdt.core/model/org/eclipse/jdt/core/JavaCore.java
index 2b46bf9bc6..cbf643deda 100644
--- a/jdt-patch/e421/org.eclipse.jdt.core/model/org/eclipse/jdt/core/JavaCore.java
+++ b/jdt-patch/e421/org.eclipse.jdt.core/model/org/eclipse/jdt/core/JavaCore.java
@@ -5219,7 +5219,7 @@ public static IClasspathEntry newLibraryEntry(
 		return new ClasspathEntry(
 			IPackageFragmentRoot.K_BINARY,
 			IClasspathEntry.CPE_LIBRARY,
-			hasDotDot ? path : JavaProject.canonicalizedPath(path),
+			hasDotDot ? path : JavaProject.createPackageFragementKey(path),
 			ClasspathEntry.INCLUDE_ALL, // inclusion patterns
 			ClasspathEntry.EXCLUDE_NONE, // exclusion patterns
 			sourceAttachmentPath,
diff --git a/jdt-patch/e421/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/DeltaProcessor.java b/jdt-patch/e421/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/DeltaProcessor.java
index dead7518bb..c10d6ce096 100644
--- a/jdt-patch/e421/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/DeltaProcessor.java
+++ b/jdt-patch/e421/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/DeltaProcessor.java
@@ -139,7 +139,7 @@ public IPackageFragmentRoot getPackageFragmentRoot() {
 			if (target instanceof IResource) {
 				tRoot = this.project.getPackageFragmentRoot((IResource)target, this.rootPath, this.extraAttributes);
 			} else {
-				IPath canonicalizedPath = JavaProject.canonicalizedPath(new Path(this.rootPath.toOSString()));
+				IPath canonicalizedPath = JavaProject.createPackageFragementKey(new Path(this.rootPath.toOSString()));
 				tRoot = this.project.getPackageFragmentRoot0(canonicalizedPath, this.extraAttributes);
 			}
 			return tRoot;
diff --git a/jdt-patch/e421/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/JavaModelManager.java b/jdt-patch/e421/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/JavaModelManager.java
index 3dbb55ac8a..474d66b436 100644
--- a/jdt-patch/e421/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/JavaModelManager.java
+++ b/jdt-patch/e421/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/JavaModelManager.java
@@ -183,7 +183,7 @@ public class JavaModelManager implements ISaveParticipant, IContentTypeChangeLis
 	private static final String ASSUMED_EXTERNAL_FILES_CACHE = "assumedExternalFilesCache";  //$NON-NLS-1$
 
 	public static enum ArchiveValidity {
-		BAD_FORMAT, UNABLE_TO_READ, FILE_NOT_FOUND, VALID;
+		INVALID, VALID;
 
 		public boolean isValid() {
 			return this == VALID;
@@ -1331,7 +1331,7 @@ public void rememberExternalLibTimestamps() {
 		}
 
 		public synchronized ClasspathChange resetResolvedClasspath() {
-			// clear non-chaining jars cache and invalid jars cache
+			// clear non-chaining jars cache and external jars cache
 			JavaModelManager.getJavaModelManager().resetClasspathListCache();
 
 			// null out resolved information
@@ -1623,11 +1623,10 @@ private static class InvalidArchiveInfo {
 	}
 
 	/*
-	 * A map of IPaths for jars that are known to be invalid (such as not being in a valid/known format), to an eviction timestamp.
-	 * Synchronize on invalidArchivesMutex before accessing.
+	 * A map of IPaths for jars with known validity (such as being in a valid/known format or not), to an eviction timestamp.
+	 * Synchronize on invalidArchives before accessing.
 	 */
 	private final Map<IPath, InvalidArchiveInfo> invalidArchives = new HashMap<>();
-	private final Object invalidArchivesMutex = new Object();
 
 	/*
 	 * A set of IPaths for files that are known to be external to the workspace.
@@ -1799,9 +1798,9 @@ public void addNonChainingJar(IPath path) {
 
 	public void addInvalidArchive(IPath path, ArchiveValidity reason) {
 		if (DEBUG_INVALID_ARCHIVES) {
-			System.out.println("Invalid JAR cache: adding " + path + ", reason: " + reason);  //$NON-NLS-1$//$NON-NLS-2$
+			System.out.println("JAR cache: adding " + reason + " " + path);  //$NON-NLS-1$//$NON-NLS-2$
 		}
-		synchronized (this.invalidArchivesMutex) {
+		synchronized (this.invalidArchives) {
 			this.invalidArchives.put(path, new InvalidArchiveInfo(System.currentTimeMillis() + INVALID_ARCHIVE_TTL_MILLISECONDS, reason));
 		}
 	}
@@ -2846,7 +2845,9 @@ public void verifyArchiveContent(IPath path) throws CoreException {
 		if (isJrt(path)) {
 			return;
 		}
-		throwExceptionIfArchiveInvalid(path);
+		if (isArchiveStateKnownToBeValid(path)) {
+			return; // known to be valid
+		}
 		ZipFile file = getZipFile(path);
 		closeZipFile(file);
 	}
@@ -2880,7 +2881,7 @@ public ZipFile getZipFile(IPath path) throws CoreException {
 
 	public ZipFile getZipFile(IPath path, boolean checkInvalidArchiveCache) throws CoreException {
 		if (checkInvalidArchiveCache) {
-			throwExceptionIfArchiveInvalid(path);
+			isArchiveStateKnownToBeValid(path);
 		}
 		ZipCache zipCache;
 		ZipFile zipFile;
@@ -2901,17 +2902,11 @@ public ZipFile getZipFile(IPath path, boolean checkInvalidArchiveCache) throws C
 			if (zipCache != null) {
 				zipCache.setCache(path, zipFile);
 			}
+			addInvalidArchive(path, ArchiveValidity.VALID); // remember its valid
 			return zipFile;
 		} catch (IOException e) {
-			ArchiveValidity reason;
-
-			if (e instanceof ZipException) {
-				reason = ArchiveValidity.BAD_FORMAT;
-			} else if (e instanceof FileNotFoundException) {
-				reason = ArchiveValidity.FILE_NOT_FOUND;
-			} else {
-				reason = ArchiveValidity.UNABLE_TO_READ;
-			}
+			// file may exist but for some reason is inaccessible
+			ArchiveValidity reason=ArchiveValidity.INVALID;
 			addInvalidArchive(path, reason);
 			throw new CoreException(new Status(IStatus.ERROR, JavaCore.PLUGIN_ID, -1, Messages.status_IOException, e));
 		}
@@ -2937,18 +2932,12 @@ public static File getLocalFile(IPath path) throws CoreException {
 		return localFile;
 	}
 
-	private void throwExceptionIfArchiveInvalid(IPath path) throws CoreException {
+	private boolean isArchiveStateKnownToBeValid(IPath path) throws CoreException {
 		ArchiveValidity validity = getArchiveValidity(path);
-		IOException reason;
-		switch (validity) {
-			case BAD_FORMAT: reason = new ZipException("Bad format in archive: " + path); break; //$NON-NLS-1$
-			case FILE_NOT_FOUND: reason = new FileNotFoundException("Archive not found for path: " + path); break; //$NON-NLS-1$
-			case UNABLE_TO_READ: reason = new IOException("Unable to read archive: " + path); break; //$NON-NLS-1$
-			default: reason = null;
-		}
-		if (reason != null) {
-			throw new CoreException(new Status(IStatus.ERROR, JavaCore.PLUGIN_ID, -1, Messages.status_IOException, reason));
+		if (validity == null || validity == ArchiveValidity.INVALID) {
+			return false; // chance the file has become accessible/readable now.
 		}
+		return true;
 	}
 
 	/*
@@ -3404,18 +3393,23 @@ public boolean isNonChainingJar(IPath path) {
 
 	public ArchiveValidity getArchiveValidity(IPath path) {
 		InvalidArchiveInfo invalidArchiveInfo;
-		synchronized (this.invalidArchivesMutex) {
+		synchronized (this.invalidArchives) {
 			invalidArchiveInfo = this.invalidArchives.get(path);
 		}
-		if (invalidArchiveInfo == null)
-			return ArchiveValidity.VALID;
+		if (invalidArchiveInfo == null) {
+			if (DEBUG_INVALID_ARCHIVES) {
+				System.out.println("JAR cache: UNKNOWN validity for " + path);  //$NON-NLS-1$
+			}
+			return null;
+		}
 		long now = System.currentTimeMillis();
 
 		// If the TTL for this cache entry has expired, directly check whether the archive is still invalid.
 		// If it transitioned to being valid, remove it from the cache and force an update to project caches.
 		if (now > invalidArchiveInfo.evictionTimestamp) {
 			try {
-				getZipFile(path, false);
+				ZipFile zipFile = getZipFile(path, false);
+				closeZipFile(zipFile);
 				removeFromInvalidArchiveCache(path);
 			} catch (CoreException e) {
 				// Archive is still invalid, fall through to reporting it is invalid.
@@ -3423,14 +3417,24 @@ public ArchiveValidity getArchiveValidity(IPath path) {
 			// Retry the test from the start, now that we have an up-to-date result
 			return getArchiveValidity(path);
 		}
+		if (DEBUG_INVALID_ARCHIVES) {
+			System.out.println("JAR cache: " + invalidArchiveInfo.reason + " " + path);  //$NON-NLS-1$ //$NON-NLS-2$
+		}
 		return invalidArchiveInfo.reason;
 	}
 
 	public void removeFromInvalidArchiveCache(IPath path) {
-		synchronized(this.invalidArchivesMutex) {
+		synchronized(this.invalidArchives) {
+			InvalidArchiveInfo entry = this.invalidArchives.get(path);
+			if (entry != null && entry.reason == ArchiveValidity.VALID) {
+				if (DEBUG_INVALID_ARCHIVES) {
+					System.out.println("JAR cache: keep VALID " + path);  //$NON-NLS-1$
+				}
+				return; // do not remove the VALID information
+			}
 			if (this.invalidArchives.remove(path) != null) {
 				if (DEBUG_INVALID_ARCHIVES) {
-					System.out.println("Invalid JAR cache: removed " + path);  //$NON-NLS-1$
+					System.out.println("JAR cache: removed INVALID " + path);  //$NON-NLS-1$
 				}
 				try {
 					// Bug 455042: Force an update of the JavaProjectElementInfo project caches.
@@ -4297,16 +4301,6 @@ protected synchronized void resetJarTypeCache() {
 	public void resetClasspathListCache() {
 		if (this.nonChainingJars != null)
 			this.nonChainingJars.clear();
-		if (DEBUG_INVALID_ARCHIVES) {
-			synchronized(this.invalidArchivesMutex) {
-				if (!this.invalidArchives.isEmpty()) {
-					System.out.println("Invalid JAR cache: clearing cache"); //$NON-NLS-1$
-				}
-			}
-		}
-		synchronized(this.invalidArchivesMutex) {
-			this.invalidArchives.clear();
-		}
 		if (this.externalFiles != null)
 			this.externalFiles.clear();
 		if (this.assumedExternalFiles != null)
diff --git a/jdt-patch/e421/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/JavaProject.java b/jdt-patch/e421/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/JavaProject.java
index 26cac541c5..2a98bc095f 100644
--- a/jdt-patch/e421/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/JavaProject.java
+++ b/jdt-patch/e421/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/JavaProject.java
@@ -151,8 +151,14 @@ public class JavaProject
 
 	/**
 	 * Whether the underlying file system is case sensitive.
+	 * @deprecated case sensitivity is not a constant but can be configured at runtime for individual folders (see bug 571614#c8)
 	 */
-	protected static final boolean IS_CASE_SENSITIVE = !new File("Temp").equals(new File("temp")); //$NON-NLS-1$ //$NON-NLS-2$
+	@Deprecated
+	private static final boolean IS_CASE_SENSITIVE = !new File("Temp").equals(new File("temp")); //$NON-NLS-1$ //$NON-NLS-2$
+	/**
+	 * ignore case insensitivity by default (see bug 571614#c8)
+	 */
+	static final boolean RESOLVE_ACTUAL_PACKAGEFRAGMENT_NAME = Boolean.getBoolean("org.eclipse.jdt.resolve_actual_packagefragment_name"); //$NON-NLS-1$
 
 	/**
 	 * An empty array of strings indicating that a project doesn't have any prerequesite projects.
@@ -310,21 +316,48 @@ private static boolean areClasspathsEqual(IClasspathEntry[] first, IClasspathEnt
 		return true;
 	}
 
+	/**
+	 * Does nothing by default. With system flag org.eclipse.jdt.resolve_actual_packagefragment_name=true it tries to find the actual filename
+	 */
+	public static IPath createPackageFragementKey(IPath externalPath) {
+		if (RESOLVE_ACTUAL_PACKAGEFRAGMENT_NAME) { //disabled by default
+			return capitailzePath(externalPath);
+		} else {
+			// trust the UI to already have resolved the actual capitalization:
+			return externalPath;  // do nothing
+		}
+	}
+
 	/**
 	 * Returns a canonicalized path from the given external path.
 	 * Note that the return path contains the same number of segments
 	 * and it contains a device only if the given path contained one.
 	 * @param externalPath IPath
-	 * @see java.io.File for the definition of a canonicalized path
 	 * @return IPath
+	 * @deprecated This method may not do what you expect from its name (see bug 571614):
+	 *             <p> On Linux/Mac (CASE_SENSITIVE by default) it does nothing - even when pointing to a case insensitive filesystem.
+	 *             <p> On Windows (CASE_INSENSITIVE by default) it will find the actual capitalization of all path segments.
+	 *             On Windows it will also resolve 8.3 filenames to its long names.
+	 *             On Windows this results in slow system calls for every segment of the path since JDK 12
+	 *             (see https://bugs.openjdk.java.net/browse/JDK-8207005) - even when the filesystem is configured to
+	 *             be case sensitive and 8.3 name resolving is disabled.
+	 *             <p> ALTERNATIVES:
+	 *             <p> For package fragments use {@link #createPackageFragementKey}
+	 *             <p> For comparing files use {@link java.nio.file.Files#isSameFile}
+	 *         	   <p> For getting the actual capitalization use {@link java.nio.file.Path#toRealPath}
 	 */
+	@Deprecated
 	public static IPath canonicalizedPath(IPath externalPath) {
+		return capitailzePath(externalPath);
+	}
+
+    private static IPath capitailzePath(IPath externalPath) {
 
 		if (externalPath == null)
 			return null;
 
-		if (IS_CASE_SENSITIVE) {
-			return externalPath;
+		if (IS_CASE_SENSITIVE) { // if Linux/Mac
+			return externalPath; // do nothing
 		}
 
 		// if not external path, return original path
@@ -1583,7 +1616,7 @@ public IJavaElement findElement(String bindingKey, WorkingCopyOwner owner) throw
 	public IPackageFragment findPackageFragment(IPath path)
 		throws JavaModelException {
 
-		return findPackageFragment0(JavaProject.canonicalizedPath(path));
+		return findPackageFragment0(createPackageFragementKey(path));
 	}
 	/*
 	 * non path canonicalizing version
@@ -1602,7 +1635,7 @@ private IPackageFragment findPackageFragment0(IPath path)
 	public IPackageFragmentRoot findPackageFragmentRoot(IPath path)
 		throws JavaModelException {
 
-		return findPackageFragmentRoot0(JavaProject.canonicalizedPath(path));
+		return findPackageFragmentRoot0(createPackageFragementKey(path));
 	}
 	/*
 	 * no path canonicalization
@@ -2332,7 +2365,7 @@ public IPackageFragmentRoot getPackageFragmentRoot(IResource resource, IPath ent
 	 */
 	@Override
 	public IPackageFragmentRoot getPackageFragmentRoot(String externalLibraryPath) {
-		return getPackageFragmentRoot0(JavaProject.canonicalizedPath(new Path(externalLibraryPath)), null);
+		return getPackageFragmentRoot0(createPackageFragementKey(new Path(externalLibraryPath)), null);
 	}
 
 	/*
diff --git a/jdt-patch/e421/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/JavaProjectElementInfo.java b/jdt-patch/e421/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/JavaProjectElementInfo.java
index 619011cc5a..15ddf3bf71 100644
--- a/jdt-patch/e421/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/JavaProjectElementInfo.java
+++ b/jdt-patch/e421/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/JavaProjectElementInfo.java
@@ -212,7 +212,7 @@ ProjectCache getProjectCache(JavaProject project, boolean excludeTestCode) {
 		if (cache != null) {
 			for (IPackageFragmentRoot root : cache.allPkgFragmentRootsCache) {
 				IJavaProject rootProject = root.getJavaProject();
-				if (rootProject != this && !rootProject.exists()) {
+				if (rootProject != project && !rootProject.exists()) {
 					cache = null; // force rebuilding
 					break;
 				}
diff --git a/pom.xml b/pom.xml
index 2e0a6b8571..b9fe39f181 100644
--- a/pom.xml
+++ b/pom.xml
@@ -124,9 +124,9 @@
 					<url>https://download.eclipse.org/eclipse/updates/4.21</url>
 				</repository>
 				<repository>
-					<id>2021-09-M1</id>
+					<id>2021-09-M3</id>
 					<layout>p2</layout>
-					<url>https://download.eclipse.org/eclipse/updates/4.21-I-builds/I20210729-1800</url>
+					<url>https://download.eclipse.org/eclipse/updates/4.21-I-builds/I20210818-1800</url>
 				</repository>
 			</repositories>
 			<modules>