diff --git a/JCL/javax23api/src/javax/lang/model/util/Types.java b/JCL/javax23api/src/javax/lang/model/util/Types.java
index c62c3b0b8f0..087a896fd1d 100644
--- a/JCL/javax23api/src/javax/lang/model/util/Types.java
+++ b/JCL/javax23api/src/javax/lang/model/util/Types.java
@@ -48,4 +48,7 @@ DeclaredType getDeclaredType(DeclaredType containing,
                                  TypeElement typeElem, TypeMirror... typeArgs);
 
     TypeMirror asMemberOf(DeclaredType containing, Element element);
+    default <T extends TypeMirror> T stripAnnotations(T t) {
+        throw new UnsupportedOperationException();
+    }
 }
diff --git a/org.eclipse.jdt.compiler.apt.tests/META-INF/MANIFEST.MF b/org.eclipse.jdt.compiler.apt.tests/META-INF/MANIFEST.MF
index 6ef32b06cf0..7cac8a55de0 100644
--- a/org.eclipse.jdt.compiler.apt.tests/META-INF/MANIFEST.MF
+++ b/org.eclipse.jdt.compiler.apt.tests/META-INF/MANIFEST.MF
@@ -2,7 +2,7 @@ Manifest-Version: 1.0
 Bundle-ManifestVersion: 2
 Bundle-Name: %pluginName
 Bundle-SymbolicName: org.eclipse.jdt.compiler.apt.tests;singleton:=true
-Bundle-Version: 1.3.600.qualifier
+Bundle-Version: 1.3.700.qualifier
 Bundle-Vendor: %providerName
 Bundle-Localization: plugin
 Bundle-RequiredExecutionEnvironment: JavaSE-17
diff --git a/org.eclipse.jdt.compiler.apt.tests/lib/apttestprocessors8.jar b/org.eclipse.jdt.compiler.apt.tests/lib/apttestprocessors8.jar
index feeb10e708d..c3b8570be26 100644
Binary files a/org.eclipse.jdt.compiler.apt.tests/lib/apttestprocessors8.jar and b/org.eclipse.jdt.compiler.apt.tests/lib/apttestprocessors8.jar differ
diff --git a/org.eclipse.jdt.compiler.apt.tests/lib/javax23api.jar b/org.eclipse.jdt.compiler.apt.tests/lib/javax23api.jar
index 092d51a765d..f7ca9689573 100644
Binary files a/org.eclipse.jdt.compiler.apt.tests/lib/javax23api.jar and b/org.eclipse.jdt.compiler.apt.tests/lib/javax23api.jar differ
diff --git a/org.eclipse.jdt.compiler.apt.tests/pom.xml b/org.eclipse.jdt.compiler.apt.tests/pom.xml
index 0675ac29f65..c46433f657c 100644
--- a/org.eclipse.jdt.compiler.apt.tests/pom.xml
+++ b/org.eclipse.jdt.compiler.apt.tests/pom.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
-  Copyright (c) 2012, 2023 Eclipse Foundation and others.
+  Copyright (c) 2012, 2024 Eclipse Foundation and others.
   All rights reserved. This program and the accompanying materials
   are made available under the terms of the Eclipse Distribution License v1.0
   which accompanies this distribution, and is available at
@@ -19,7 +19,7 @@
     <relativePath>../tests-pom/</relativePath>
   </parent>
   <artifactId>org.eclipse.jdt.compiler.apt.tests</artifactId>
-  <version>1.3.600-SNAPSHOT</version>
+  <version>1.3.700-SNAPSHOT</version>
   <packaging>eclipse-test-plugin</packaging>
 
   <properties>
diff --git a/org.eclipse.jdt.compiler.apt.tests/processors8/org/eclipse/jdt/compiler/apt/tests/processors/elements/Java23ElementProcessor.java b/org.eclipse.jdt.compiler.apt.tests/processors8/org/eclipse/jdt/compiler/apt/tests/processors/elements/Java23ElementProcessor.java
index b1f55927621..062969faba7 100644
--- a/org.eclipse.jdt.compiler.apt.tests/processors8/org/eclipse/jdt/compiler/apt/tests/processors/elements/Java23ElementProcessor.java
+++ b/org.eclipse.jdt.compiler.apt.tests/processors8/org/eclipse/jdt/compiler/apt/tests/processors/elements/Java23ElementProcessor.java
@@ -27,9 +27,14 @@
 import javax.annotation.processing.SupportedAnnotationTypes;
 import javax.annotation.processing.SupportedSourceVersion;
 import javax.lang.model.SourceVersion;
+import javax.lang.model.element.AnnotationMirror;
 import javax.lang.model.element.Element;
 import javax.lang.model.element.ExecutableElement;
 import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.TypeKind;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.util.ElementFilter;
 import javax.lang.model.util.Elements.DocCommentKind;
 import org.eclipse.jdt.compiler.apt.tests.processors.base.BaseProcessor;
 
@@ -206,6 +211,53 @@ public void testMarkdownContent3() throws IOException {
 				+ "@param p parameter", docComment);
 	}
 
+	public void testStripAnnotations() {
+		String typeName = "my.mod.Main3";
+		String annotationName = "my.annot.MyAnnotation";
+		TypeElement typeElement = _elementUtils.getTypeElement(typeName);
+		List<? extends TypeMirror> interfaces = typeElement.getInterfaces();
+		assertEquals("Wrong no of super interfaces", 1, interfaces.size());
+		TypeMirror superclass = interfaces.get(0);
+		List<? extends AnnotationMirror> annotations = superclass.getAnnotationMirrors();
+		assertEquals("Incorrect no of annotations", 1, annotations.size());
+		TypeMirror withoutAnnotations = _typeUtils.stripAnnotations(superclass);
+		assertTrue("Type should not have any annotations", withoutAnnotations.getAnnotationMirrors().isEmpty());
+		assertTrue("Should be of the same type", _typeUtils.isSameType(superclass, withoutAnnotations));
+		List<ExecutableElement> methods = ElementFilter.methodsIn(typeElement.getEnclosedElements());
+		for (ExecutableElement method : methods) {
+			if (method.getSimpleName().toString().equals("run")) {
+				continue;
+			}
+			TypeMirror typeMirror = method.getReturnType();
+
+			TypeMirror expAnnotation = _elementUtils.getTypeElement(annotationName).asType();
+			annotations = typeMirror.getAnnotationMirrors();
+			assertEquals("Incorrect no of annotations", 1, annotations.size());
+			DeclaredType annotationType = typeMirror.getAnnotationMirrors().get(0).getAnnotationType();
+			assertTrue("Incorrecton annotation type", _typeUtils.isSameType(expAnnotation, annotationType));
+
+			// after stripAnnotations() TypeMirror should not have any annotations.
+			withoutAnnotations = _typeUtils.stripAnnotations(typeMirror);
+			assertTrue("Type should not have any annotations", withoutAnnotations.getAnnotationMirrors().isEmpty());
+
+			TypeMirror typeMirror1 = null;
+			if (typeMirror.getKind() != TypeKind.WILDCARD) {
+				assertTrue("Should be of the same type", _typeUtils.isSameType(typeMirror, withoutAnnotations));
+			} else {
+				typeMirror1 = _typeUtils.getWildcardType(typeMirror, null);
+				annotations = typeMirror.getAnnotationMirrors();
+				assertTrue("Type should not have any annotations", typeMirror1.getAnnotationMirrors().isEmpty());
+			}
+
+			typeMirror1 = _typeUtils.erasure(typeMirror);
+			annotations = typeMirror.getAnnotationMirrors();
+			assertEquals("Incorrect no of annotations", 1, annotations.size());
+
+			typeMirror1 = _typeUtils.getArrayType(typeMirror);
+			annotations = typeMirror.getAnnotationMirrors();
+			assertEquals("Incorrect no of annotations", 1, annotations.size());
+		}
+	}
 	@Override
 	public void reportError(String msg) {
 		throw new AssertionFailedError(msg);
@@ -253,6 +305,11 @@ public void assertNotNull(String msg, Object obj) {
 			reportError(msg);
 		}
 	}
+	public void assertTrue(String msg, boolean result) {
+		if (!result) {
+			reportError(msg);
+		}
+	}
 	private static class AssertionFailedError extends Error {
 		private static final long serialVersionUID = 1L;
 
diff --git a/org.eclipse.jdt.compiler.apt.tests/processors8/org/eclipse/jdt/compiler/apt/tests/processors/elements/Java9ElementProcessor.java b/org.eclipse.jdt.compiler.apt.tests/processors8/org/eclipse/jdt/compiler/apt/tests/processors/elements/Java9ElementProcessor.java
index 819d1adfc6f..858b5b600f7 100644
--- a/org.eclipse.jdt.compiler.apt.tests/processors8/org/eclipse/jdt/compiler/apt/tests/processors/elements/Java9ElementProcessor.java
+++ b/org.eclipse.jdt.compiler.apt.tests/processors8/org/eclipse/jdt/compiler/apt/tests/processors/elements/Java9ElementProcessor.java
@@ -538,7 +538,7 @@ public void testModuleTypeMirror1() {
 		TypeMirror asType = base.asType();
 		assertNotNull("module type should not be null", asType);
 		assertEquals("incorrect type kind", TypeKind.MODULE, asType.getKind());
-		assertEquals("must be a NoType", (asType instanceof NoType));
+		assertTrue("must be a NoType", (asType instanceof NoType));
 	}
 	public void testModuleTypeMirror2() {
 		ModuleElement base = _elementUtils.getModuleElement("mod.a");
@@ -1308,11 +1308,6 @@ public void assertEquals(String msg, int expected, int actual) {
 			reportError(buf.toString());
 		}
 	}
-	public void assertEquals(Object expected, Object actual) {
-		if (expected != actual) {
-
-		}
-	}
 	private void verifyAnnotations(AnnotatedConstruct construct, String[] annots) {
 		List<? extends AnnotationMirror> annotations = construct.getAnnotationMirrors();
 		assertEquals("Incorrect no of annotations", annots.length, annotations.size());
diff --git a/org.eclipse.jdt.compiler.apt.tests/resources/mod_locations/modules23/module.main/my/annot/MyAnnotation.java b/org.eclipse.jdt.compiler.apt.tests/resources/mod_locations/modules23/module.main/my/annot/MyAnnotation.java
new file mode 100644
index 00000000000..cc1a9b9435a
--- /dev/null
+++ b/org.eclipse.jdt.compiler.apt.tests/resources/mod_locations/modules23/module.main/my/annot/MyAnnotation.java
@@ -0,0 +1,7 @@
+package my.annot;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+@Target(ElementType.TYPE_USE)
+public @interface MyAnnotation {
+    String value() default "";
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.compiler.apt.tests/resources/mod_locations/modules23/module.main/my/mod/Main3.java b/org.eclipse.jdt.compiler.apt.tests/resources/mod_locations/modules23/module.main/my/mod/Main3.java
new file mode 100644
index 00000000000..1172cb1fa7d
--- /dev/null
+++ b/org.eclipse.jdt.compiler.apt.tests/resources/mod_locations/modules23/module.main/my/mod/Main3.java
@@ -0,0 +1,41 @@
+package my.mod;
+
+import my.annot.*;
+
+public class Main3 implements @MyAnnotation Runnable {
+
+	public void run() {
+	}
+
+	public static @MyAnnotation("1") int method1() {
+		return 0;
+	}
+
+	public static @MyAnnotation("2") Integer method2() {
+		return null;
+	}
+
+	public static @MyAnnotation("3") String method3() {
+		return null;
+	}
+
+	public static String @MyAnnotation("4") [] method4() {
+		return null;
+	}
+
+	public static java.util.@MyAnnotation("5") Set<@MyAnnotation("6") String> method5() {
+		return null;
+	}
+
+	public static <@MyAnnotation("7") T extends @MyAnnotation("8") String> @MyAnnotation("9") T method6() {
+		return null;
+	}
+
+	public static java.util.@MyAnnotation("10") Set<@MyAnnotation("11") ? extends @MyAnnotation("12") Number> method7() {
+		return null;
+	}
+
+	public static <@MyAnnotation("13") S extends Number & Runnable> @MyAnnotation("14") S method8() {
+		return null;
+	}
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.compiler.apt.tests/src/org/eclipse/jdt/compiler/apt/tests/AnnotationProcessorTests.java b/org.eclipse.jdt.compiler.apt.tests/src/org/eclipse/jdt/compiler/apt/tests/AnnotationProcessorTests.java
index 8b91a666339..fc4d67452ca 100644
--- a/org.eclipse.jdt.compiler.apt.tests/src/org/eclipse/jdt/compiler/apt/tests/AnnotationProcessorTests.java
+++ b/org.eclipse.jdt.compiler.apt.tests/src/org/eclipse/jdt/compiler/apt/tests/AnnotationProcessorTests.java
@@ -17,6 +17,7 @@
 
 import java.io.File;
 import java.io.IOException;
+import java.io.StringWriter;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Locale;
@@ -217,4 +218,81 @@ public void testBug530665() throws IOException {
 		assertTrue(!preexistsFile.exists()); // deleted
 		assertTrue(nonexistsFile.exists()); // rewritten
 	}
+	public void testGHIssue2347_1() throws IOException {
+		JavaCompiler compiler = BatchTestUtils.getEclipseCompiler();
+		File folder = TestUtils.concatPath(BatchTestUtils.getSrcFolderName(), "targets", "AnnotationProcessorTests", "bug540090");
+		BatchTestUtils.copyResources("targets/AnnotationProcessorTests/bug540090", folder);
+		List<String> options = new ArrayList<>();
+		final String PROC = "org.eclipse.jdt.compiler.apt.tests.processors.AnnotationProcessorTests.Bug540090Proc";
+		options.add("-processorpath");
+		options.add(" ");
+		options.add("-processor");
+		options.add(PROC);
+		options.add("-proc:full");
+		options.add("-verbose");
+		StringWriter stringWriter = new StringWriter();
+		BatchTestUtils.compileTree(stringWriter, compiler, options, folder, null);
+		folder = TestUtils.concatPath(BatchTestUtils.getBinFolderName(), "targets", "AnnotationProcessorTests", "bug540090");
+		String output = stringWriter.getBuffer().toString();
+		assertTrue("Files not generated as expected", output.contains("[3 .class files generated]"));
+	}
+	public void testGHIssue2347_2() throws IOException {
+		JavaCompiler compiler = BatchTestUtils.getEclipseCompiler();
+		File folder = TestUtils.concatPath(BatchTestUtils.getSrcFolderName(), "targets", "AnnotationProcessorTests", "bug540090");
+		BatchTestUtils.copyResources("targets/AnnotationProcessorTests/bug540090", folder);
+		List<String> options = new ArrayList<>();
+		final String PROC = "org.eclipse.jdt.compiler.apt.tests.processors.AnnotationProcessorTests.Bug540090Proc";
+		options.add("-processorpath");
+		options.add(" ");
+		options.add("-processor");
+		options.add(PROC);
+		options.add("-proc:only");
+		options.add("-proc:full");
+		options.add("-verbose");
+		StringWriter stringWriter = new StringWriter();
+		BatchTestUtils.compileTree(stringWriter, compiler, options, folder, null);
+		folder = TestUtils.concatPath(BatchTestUtils.getBinFolderName(), "targets", "AnnotationProcessorTests", "bug540090");
+		String output = stringWriter.getBuffer().toString();
+		assertTrue("Files not generated as expected", output.contains("[3 .class files generated]"));
+
+	}
+	public void testGHIssue2347_3() throws IOException {
+		JavaCompiler compiler = BatchTestUtils.getEclipseCompiler();
+		File folder = TestUtils.concatPath(BatchTestUtils.getSrcFolderName(), "targets", "AnnotationProcessorTests", "bug540090");
+		BatchTestUtils.copyResources("targets/AnnotationProcessorTests/bug540090", folder);
+		List<String> options = new ArrayList<>();
+		final String PROC = "org.eclipse.jdt.compiler.apt.tests.processors.AnnotationProcessorTests.Bug540090Proc";
+		options.add("-processorpath");
+		options.add(" ");
+		options.add("-processor");
+		options.add(PROC);
+		options.add("-proc:none");
+		options.add("-proc:full");
+		options.add("-verbose");
+		StringWriter stringWriter = new StringWriter();
+		BatchTestUtils.compileTree(stringWriter, compiler, options, folder, null);
+		folder = TestUtils.concatPath(BatchTestUtils.getBinFolderName(), "targets", "AnnotationProcessorTests", "bug540090");
+		String output = stringWriter.getBuffer().toString();
+		assertTrue("Files not generated as expected", output.contains("[3 .class files generated]"));
+	}
+	public void testGHIssue2347_4() throws IOException {
+		JavaCompiler compiler = BatchTestUtils.getEclipseCompiler();
+		File folder = TestUtils.concatPath(BatchTestUtils.getSrcFolderName(), "targets", "AnnotationProcessorTests", "bug540090");
+		BatchTestUtils.copyResources("targets/AnnotationProcessorTests/bug540090", folder);
+		List<String> options = new ArrayList<>();
+		final String PROC = "org.eclipse.jdt.compiler.apt.tests.processors.AnnotationProcessorTests.Bug540090Proc";
+		options.add("-processorpath");
+		options.add(" ");
+		options.add("-processor");
+		options.add(PROC);
+		options.add("-proc:none");
+		options.add("-proc:only");
+		BatchTestUtils.compileTree(compiler, options, folder, null);
+		folder = TestUtils.concatPath(BatchTestUtils.getBinFolderName(), "targets", "AnnotationProcessorTests", "bug540090");
+		File classfile = new File(folder, "B.class");
+		assertFalse(classfile.exists());
+		folder = TestUtils.concatPath(BatchTestUtils.getGenFolderName(), "gen");
+		classfile = new File(folder, "GenClass.java");
+		assertTrue(classfile.exists());
+	}
 }
diff --git a/org.eclipse.jdt.compiler.apt.tests/src/org/eclipse/jdt/compiler/apt/tests/BatchTestUtils.java b/org.eclipse.jdt.compiler.apt.tests/src/org/eclipse/jdt/compiler/apt/tests/BatchTestUtils.java
index 49ac68913dd..65be47f0cd6 100644
--- a/org.eclipse.jdt.compiler.apt.tests/src/org/eclipse/jdt/compiler/apt/tests/BatchTestUtils.java
+++ b/org.eclipse.jdt.compiler.apt.tests/src/org/eclipse/jdt/compiler/apt/tests/BatchTestUtils.java
@@ -137,6 +137,11 @@ public static void compileTree(JavaCompiler compiler, List<String> options, File
 		compileTree(compiler, options, targetFolder, false);
 	}
 
+	public static void compileTree(StringWriter stringWriter, JavaCompiler compiler, List<String> options, File targetFolder,
+			DiagnosticListener<? super JavaFileObject> listener) {
+		compileTree(stringWriter, compiler, options, targetFolder, false, listener);
+	}
+
 	public static void compileTree(JavaCompiler compiler, List<String> options, File targetFolder,
 			DiagnosticListener<? super JavaFileObject> listener) {
 		compileTree(compiler, options, targetFolder, false, listener);
@@ -230,13 +235,18 @@ public int compare(File f1, File f2) {
 	public static void compileTree(JavaCompiler compiler, List<String> options,
 			File targetFolder, boolean useJLS8Processors,
 			DiagnosticListener<? super JavaFileObject> listener) {
+		StringWriter stringWriter = new StringWriter();
+		compileTree(stringWriter, compiler, options, targetFolder, useJLS8Processors, listener);
+	}
+	public static void compileTree(StringWriter stringWriter, JavaCompiler compiler, List<String> options,
+			File targetFolder, boolean useJLS8Processors,
+			DiagnosticListener<? super JavaFileObject> listener) {
 		StandardJavaFileManager manager = compiler.getStandardFileManager(null, Locale.getDefault(), Charset.defaultCharset());
 
 		// create new list containing inputfile
 		List<File> files = new ArrayList<>();
 		findFilesUnder(targetFolder, files);
 		Iterable<? extends JavaFileObject> units = manager.getJavaFileObjectsFromFiles(files);
-		StringWriter stringWriter = new StringWriter();
 		PrintWriter printWriter = new PrintWriter(stringWriter);
 
 		options.add("-d");
diff --git a/org.eclipse.jdt.compiler.apt.tests/src/org/eclipse/jdt/compiler/apt/tests/Java23ElementsTests.java b/org.eclipse.jdt.compiler.apt.tests/src/org/eclipse/jdt/compiler/apt/tests/Java23ElementsTests.java
index f8551d8647a..b4d5f1a5113 100644
--- a/org.eclipse.jdt.compiler.apt.tests/src/org/eclipse/jdt/compiler/apt/tests/Java23ElementsTests.java
+++ b/org.eclipse.jdt.compiler.apt.tests/src/org/eclipse/jdt/compiler/apt/tests/Java23ElementsTests.java
@@ -54,6 +54,14 @@ public void testMarkdownContent3Javac() throws IOException {
 		JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
 		internalTestWithBinary(compiler, MODULE_PROC, "23", "testMarkdownContent3", null, "modules23", false);
 	}
+	public void testStripAnnotations() throws IOException {
+		JavaCompiler compiler = BatchTestUtils.getEclipseCompiler();
+		internalTestWithBinary(compiler, MODULE_PROC, "23", "testStripAnnotations", null, "modules23", false);
+	}
+	public void testStripAnnotationsJavac() throws IOException {
+		JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
+		internalTestWithBinary(compiler, MODULE_PROC, "23", "testStripAnnotations", null, "modules23", false);
+	}
 	@SuppressWarnings({ "rawtypes", "unchecked" })
 	protected void internalTestWithBinary(JavaCompiler compiler, String processor, String compliance, String testMethod, String testClass, String resourceArea,
 				boolean processBinariesAgain) throws IOException {
diff --git a/org.eclipse.jdt.compiler.tool.tests/META-INF/MANIFEST.MF b/org.eclipse.jdt.compiler.tool.tests/META-INF/MANIFEST.MF
index 935a43ecfd9..c5f3056e24d 100644
--- a/org.eclipse.jdt.compiler.tool.tests/META-INF/MANIFEST.MF
+++ b/org.eclipse.jdt.compiler.tool.tests/META-INF/MANIFEST.MF
@@ -2,7 +2,7 @@ Manifest-Version: 1.0
 Bundle-ManifestVersion: 2
 Bundle-Name: %pluginName
 Bundle-SymbolicName: org.eclipse.jdt.compiler.tool.tests
-Bundle-Version: 1.4.600.qualifier
+Bundle-Version: 1.4.700.qualifier
 Bundle-Vendor: %providerName
 Bundle-Localization: plugin
 Bundle-RequiredExecutionEnvironment: JavaSE-17
diff --git a/org.eclipse.jdt.compiler.tool.tests/lib/javax23api.jar b/org.eclipse.jdt.compiler.tool.tests/lib/javax23api.jar
index 092d51a765d..f7ca9689573 100644
Binary files a/org.eclipse.jdt.compiler.tool.tests/lib/javax23api.jar and b/org.eclipse.jdt.compiler.tool.tests/lib/javax23api.jar differ
diff --git a/org.eclipse.jdt.compiler.tool.tests/pom.xml b/org.eclipse.jdt.compiler.tool.tests/pom.xml
index 9f094788a42..568fc0527a2 100644
--- a/org.eclipse.jdt.compiler.tool.tests/pom.xml
+++ b/org.eclipse.jdt.compiler.tool.tests/pom.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
-  Copyright (c) 2012, 2017 Eclipse Foundation and others.
+  Copyright (c) 2012, 2024 Eclipse Foundation and others.
   All rights reserved. This program and the accompanying materials
   are made available under the terms of the Eclipse Distribution License v1.0
   which accompanies this distribution, and is available at
@@ -19,7 +19,7 @@
     <relativePath>../tests-pom/</relativePath>
   </parent>
   <artifactId>org.eclipse.jdt.compiler.tool.tests</artifactId>
-  <version>1.4.600-SNAPSHOT</version>
+  <version>1.4.700-SNAPSHOT</version>
   <packaging>eclipse-test-plugin</packaging>
   <properties>
   	<testSuite>${project.artifactId}</testSuite>
diff --git a/org.eclipse.jdt.core.compiler.batch/lib/javax23api.jar b/org.eclipse.jdt.core.compiler.batch/lib/javax23api.jar
index 092d51a765d..f7ca9689573 100644
Binary files a/org.eclipse.jdt.core.compiler.batch/lib/javax23api.jar and b/org.eclipse.jdt.core.compiler.batch/lib/javax23api.jar differ
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/core/compiler/CharOperation.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/core/compiler/CharOperation.java
index 5933dbd1958..dbb7deba4f5 100644
--- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/core/compiler/CharOperation.java
+++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/core/compiler/CharOperation.java
@@ -3750,7 +3750,7 @@ public static final char[] replace(
 		next : for (int i = 0; i < max;) {
 			int index = indexOf(toBeReplaced, array, true, i);
 			if (index == -1) {
-				i++;
+				i = max; // end
 				continue next;
 			}
 			if (occurrenceCount == starts.length) {
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/apt/model/TypesImpl.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/apt/model/TypesImpl.java
index 1209a6c2b8c..844370182dc 100644
--- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/apt/model/TypesImpl.java
+++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/apt/model/TypesImpl.java
@@ -570,4 +570,15 @@ public PrimitiveType unboxedType(TypeMirror t) {
         return (PrimitiveType) this._env.getFactory().newTypeMirror(unboxed);
     }
 
+	@Override
+	@SuppressWarnings("unchecked")
+	public <T extends TypeMirror> T stripAnnotations(T t) {
+        if (t instanceof TypeMirrorImpl typeImpl) {
+        	Binding b = typeImpl.binding();
+        	if (b instanceof TypeBinding typeBinding) {
+        		 return (T) this._env.getFactory().newTypeMirror(typeBinding.unannotated());
+        	}
+        }
+        return t;
+    }
 }
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/ASTNode.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/ASTNode.java
index 1adf20c1bc7..5bf0ebf7436 100644
--- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/ASTNode.java
+++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/ASTNode.java
@@ -224,7 +224,7 @@ public abstract class ASTNode implements TypeConstants, TypeIds {
 	public static final int IsUsefulEmptyStatement = Bit1;
 
 	// for block and method declaration
-	public static final int SwitchRuleBlock = Bit1;
+	public static final int BlockShouldEndDead = Bit1;
 	public static final int UndocumentedEmptyBlock = Bit4;
 	public static final int OverridingMethodWithSupercall = Bit5;
 	public static final int CanBeStatic = Bit9;   // used to flag a method that can be declared static
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/Block.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/Block.java
index 711a57707f4..68fd1cec2e9 100644
--- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/Block.java
+++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/Block.java
@@ -74,10 +74,16 @@ public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, Fl
 			}
 		}
 	}
-	if ((this.bits & ASTNode.SwitchRuleBlock) != 0) { // switch rule blocks don't fall through
+	if ((this.bits & ASTNode.BlockShouldEndDead) != 0) { // switch rule blocks don't fall through
 		if (flowInfo != FlowInfo.DEAD_END) {
-			flowContext.recordBreakFrom(flowInfo);
-			return FlowInfo.DEAD_END;
+			if (flowContext.associatedNode instanceof SwitchExpression) { // ... demand that for expression switch ...
+				currentScope.problemReporter().switchExpressionBlockCompletesNormally(this);
+			} else { // ... enforce that for statement switch, by having the code generator inject an automagic break ...
+				flowContext.recordBreakFrom(flowInfo);
+				return FlowInfo.DEAD_END;
+			}
+		} else {
+			this.bits &= ~ASTNode.BlockShouldEndDead; // Already dead-ends; nothing special needed from code generator
 		}
 	}
 	return flowInfo;
@@ -182,17 +188,4 @@ public boolean completesByContinue() {
 	int length = this.statements == null ? 0 : this.statements.length;
 	return length > 0 && this.statements[length - 1].completesByContinue();
 }
-
-@Override
-public boolean canCompleteNormally() {
-	int length = this.statements == null ? 0 : this.statements.length;
-	return length == 0 || this.statements[length - 1].canCompleteNormally();
-}
-
-@Override
-public boolean continueCompletes() {
-	int length = this.statements == null ? 0 : this.statements.length;
-	return length > 0 && this.statements[length - 1].continueCompletes();
-}
-
 }
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/BreakStatement.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/BreakStatement.java
index c219bd09c2a..3754c4f3d78 100644
--- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/BreakStatement.java
+++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/BreakStatement.java
@@ -109,9 +109,4 @@ public void traverse(ASTVisitor visitor, BlockScope blockscope) {
 public boolean doesNotCompleteNormally() {
 	return true;
 }
-
-@Override
-public boolean canCompleteNormally() {
-	return false;
-}
 }
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/CaseStatement.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/CaseStatement.java
index 43f98c90a54..130ebf0c7d3 100644
--- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/CaseStatement.java
+++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/CaseStatement.java
@@ -40,7 +40,6 @@ public class CaseStatement extends Statement {
 
 	public BranchLabel targetLabel;
 	public Expression[] constantExpressions; // case with multiple expressions - if you want a under-the-hood view, use peeledLabelExpressions()
-	public BranchLabel[] targetLabels; // for multiple expressions
 	public boolean isSwitchRule = false;
 
 	public SwitchStatement swich; // owning switch
@@ -106,7 +105,7 @@ private boolean essentiallyQualifiedEnumerator(Expression e, TypeBinding selecto
 private void checkDuplicateDefault(BlockScope scope, ASTNode node) {
 	if (this.swich.defaultCase != null)
 		scope.problemReporter().duplicateDefaultCase(node);
-	else if (this.swich.totalPattern != null)
+	else if (this.swich.unconditionalPatternCase != null)
 		scope.problemReporter().illegalTotalPatternWithDefault(this);
 	this.swich.defaultCase = this;
 }
@@ -200,7 +199,7 @@ private Constant resolvePatternLabel(BlockScope scope, TypeBinding caseType, Typ
 		this.swich.switchBits |= SwitchStatement.Exhaustive;
 		pattern.isTotalTypeNode = true;
 		if (pattern.isUnconditional(selectorType, scope)) // unguarded is implied from 'coversType()' above
-			this.swich.totalPattern = pattern;
+			this.swich.unconditionalPatternCase = this;
 	}
  	return constant;
 }
@@ -215,11 +214,7 @@ public void resolve(BlockScope scope) {
 	this.labelExpressionOrdinal = this.swich.labelExpressionIndex;
 	this.swich.cases[this.swich.caseCount++] = this;
 
-	if (this.isSwitchRule)
-		this.swich.switchBits |= SwitchStatement.LabeledRules;
-	else
-		this.swich.switchBits |= SwitchStatement.LabeledBlockStatementGroup;
-
+	this.swich.switchBits |= this.isSwitchRule ? SwitchStatement.LabeledRules : SwitchStatement.LabeledBlockStatementGroup;
 	if ((this.swich.switchBits & (SwitchStatement.LabeledRules | SwitchStatement.LabeledBlockStatementGroup)) == (SwitchStatement.LabeledRules | SwitchStatement.LabeledBlockStatementGroup))
 		scope.problemReporter().arrowColonMixup(this);
 
@@ -229,6 +224,7 @@ public void resolve(BlockScope scope) {
 		return;
 	}
 
+	this.swich.switchBits |= SwitchStatement.HasNondefaultCase;
 	int count = 0;
 	int nullCaseCount = 0;
 	for (Expression e : this.constantExpressions) {
@@ -290,12 +286,8 @@ public void resolve(BlockScope scope) {
 				}
 				Constant constant = resolveConstantLabel(scope, caseType, selectorType, e);
 				if (constant != Constant.NotAConstant) {
-					int index = -1;
-					boolean isQualifiedEnum = false;
-					if (essentiallyQualifiedEnumerator(e, selectorType))
-						isQualifiedEnum = true;
-					else if (!(e instanceof NullLiteral))
-						index = this.swich.labelExpressionIndex;
+					int index = e instanceof NullLiteral ? -1 : this.swich.labelExpressionIndex;
+					boolean isQualifiedEnum = essentiallyQualifiedEnumerator(e, selectorType);
 					this.swich.gatherLabelExpression(new LabelExpression(constant, e, caseType, index, isQualifiedEnum));
 				}
 			}
@@ -324,13 +316,9 @@ public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, Fl
 public void generateCode(BlockScope currentScope, CodeStream codeStream) {
 	if ((this.bits & ASTNode.IsReachable) == 0)
 		return;
+
 	int pc = codeStream.position;
-	if (this.targetLabels != null) {
-		for (BranchLabel label : this.targetLabels)
-			label.place();
-	}
-	if (this.targetLabel != null)
-		this.targetLabel.place();
+	this.targetLabel.place();
 
 	if (containsPatternVariable(true)) {
 
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/ConditionalExpression.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/ConditionalExpression.java
index 384cd8fb7f9..d2932c6a4ee 100644
--- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/ConditionalExpression.java
+++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/ConditionalExpression.java
@@ -290,7 +290,6 @@ public void generateCode(
 
 		// Generate code for the condition
 		falseLabel = new BranchLabel(codeStream);
-		falseLabel.tagBits |= BranchLabel.USED;
 		this.condition.generateOptimizedBoolean(
 			currentScope,
 			codeStream,
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/ContinueStatement.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/ContinueStatement.java
index 4e439c0c39f..58e6bec74fa 100644
--- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/ContinueStatement.java
+++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/ContinueStatement.java
@@ -118,14 +118,4 @@ public boolean doesNotCompleteNormally() {
 public boolean completesByContinue() {
 	return true;
 }
-
-@Override
-public boolean canCompleteNormally() {
-	return false;
-}
-
-@Override
-public boolean continueCompletes() {
-	return true;
-}
 }
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/DoStatement.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/DoStatement.java
index b46771256c4..51e511949c7 100644
--- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/DoStatement.java
+++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/DoStatement.java
@@ -172,7 +172,6 @@ public void generateCode(BlockScope currentScope, CodeStream codeStream) {
 
 	// labels management
 	BranchLabel actionLabel = new BranchLabel(codeStream);
-	if (this.action != null) actionLabel.tagBits |= BranchLabel.USED;
 	actionLabel.place();
 	this.breakLabel.initialize(codeStream);
 	boolean hasContinueLabel = this.continueLabel != null;
@@ -274,28 +273,4 @@ public boolean doesNotCompleteNormally() {
 public boolean completesByContinue() {
 	return this.action.continuesAtOuterLabel();
 }
-
-@Override
-public boolean canCompleteNormally() {
-	Constant cst = this.condition.constant;
-	boolean isConditionTrue = cst == null || cst != Constant.NotAConstant && cst.booleanValue() == true;
-	cst = this.condition.optimizedBooleanConstant();
-	boolean isConditionOptimizedTrue = cst == null ? true : cst != Constant.NotAConstant && cst.booleanValue() == true;
-
-	if (!(isConditionTrue || isConditionOptimizedTrue)) {
-		if (this.action == null || this.action.canCompleteNormally())
-			return true;
-		if (this.action != null && this.action.continueCompletes())
-			return true;
-	}
-	if (this.action != null && this.action.breaksOut(null))
-		return true;
-
-	return false;
-}
-@Override
-public boolean continueCompletes() {
-	return this.action.continuesAtOuterLabel();
-}
-
 }
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/FakedTrackingVariable.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/FakedTrackingVariable.java
index f48813dd78f..7fb5fb3f863 100644
--- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/FakedTrackingVariable.java
+++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/FakedTrackingVariable.java
@@ -546,6 +546,7 @@ public static FlowInfo analyseCloseableAcquisition(BlockScope scope, FlowInfo fl
 				acquisition.closeTracker = tracker;
 			}
 			tracker.acquisition = acquisition;
+			tracker.globalClosingState |= SHARED_WITH_OUTSIDE;
 			FlowInfo outsideInfo = flowInfo.copy();
 			outsideInfo.markAsDefinitelyNonNull(tracker.binding);
 			tracker.markNullStatus(flowInfo, flowContext, FlowInfo.NULL);
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/ForStatement.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/ForStatement.java
index 29bff97e8f7..6092110dcff 100644
--- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/ForStatement.java
+++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/ForStatement.java
@@ -288,7 +288,6 @@ public void generateCode(BlockScope currentScope, CodeStream codeStream) {
 
 		// label management
 		BranchLabel actionLabel = new BranchLabel(codeStream);
-		actionLabel.tagBits |= BranchLabel.USED;
 		BranchLabel conditionLabel = new BranchLabel(codeStream);
 		this.breakLabel.initialize(codeStream);
 		if (this.continueLabel == null || conditionInjectsBindings) {
@@ -305,7 +304,6 @@ public void generateCode(BlockScope currentScope, CodeStream codeStream) {
 			if ((this.condition != null)
 				&& (this.condition.constant == Constant.NotAConstant)
 				&& !((this.action == null || this.action.isEmptyBlock()) && (this.increments == null))) {
-				conditionLabel.tagBits |= BranchLabel.USED;
 				int jumpPC = codeStream.position;
 				codeStream.goto_(conditionLabel);
 				codeStream.recordPositionsFrom(jumpPC, this.condition.sourceStart);
@@ -491,23 +489,4 @@ public boolean doesNotCompleteNormally() {
 	public boolean completesByContinue() {
 		return this.action.continuesAtOuterLabel();
 	}
-	@Override
-	public boolean canCompleteNormally() {
-		Constant cst = this.condition == null ? null : this.condition.constant;
-		boolean isConditionTrue = cst == null || cst != Constant.NotAConstant && cst.booleanValue() == true;
-		cst = this.condition == null ? null : this.condition.optimizedBooleanConstant();
-		boolean isConditionOptimizedTrue = cst == null ? true : cst != Constant.NotAConstant && cst.booleanValue() == true;
-
-		if (!(isConditionTrue || isConditionOptimizedTrue))
-			return true;
-		if (this.action != null && this.action.breaksOut(null))
-			return true;
-		return false;
-	}
-
-	@Override
-	public boolean continueCompletes() {
-		return this.action.continuesAtOuterLabel();
-	}
-
 }
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/ForeachStatement.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/ForeachStatement.java
index be4f819fdd9..58d929fdaca 100644
--- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/ForeachStatement.java
+++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/ForeachStatement.java
@@ -265,9 +265,7 @@ public void generateCode(BlockScope currentScope, CodeStream codeStream) {
 		}
 		// label management
 		BranchLabel actionLabel = new BranchLabel(codeStream);
-		actionLabel.tagBits |= BranchLabel.USED;
 		BranchLabel conditionLabel = new BranchLabel(codeStream);
-		conditionLabel.tagBits |= BranchLabel.USED;
 		this.breakLabel.initialize(codeStream);
 		if (this.continueLabel == null) {
 			// generate the condition (swapped for optimizing)
@@ -290,7 +288,6 @@ public void generateCode(BlockScope currentScope, CodeStream codeStream) {
 			codeStream.recordPositionsFrom(conditionPC, this.elementVariable.sourceStart);
 		} else {
 			this.continueLabel.initialize(codeStream);
-			this.continueLabel.tagBits |= BranchLabel.USED;
 			// jump over the actionBlock
 			codeStream.goto_(conditionLabel);
 		}
@@ -691,10 +688,4 @@ public void traverse(
 	public boolean doesNotCompleteNormally() {
 		return false; // may not be entered at all.
 	}
-
-	@Override
-	public boolean canCompleteNormally() {
-		return true;
-	}
-
 }
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/IfStatement.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/IfStatement.java
index 3091758ec68..c5b4eadaa04 100644
--- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/IfStatement.java
+++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/IfStatement.java
@@ -340,14 +340,4 @@ public boolean doesNotCompleteNormally() {
 public boolean completesByContinue() {
 	return this.thenStatement != null && this.thenStatement.completesByContinue() || this.elseStatement != null && this.elseStatement.completesByContinue();
 }
-@Override
-public boolean canCompleteNormally() {
-	return ((this.thenStatement == null || this.thenStatement.canCompleteNormally()) ||
-		(this.elseStatement == null || this.elseStatement.canCompleteNormally()));
-}
-@Override
-public boolean continueCompletes() {
-	return this.thenStatement != null && this.thenStatement.continueCompletes() ||
-			this.elseStatement != null && this.elseStatement.continueCompletes();
-}
 }
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/LabeledStatement.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/LabeledStatement.java
index 682dc0249e4..6cceb950492 100644
--- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/LabeledStatement.java
+++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/LabeledStatement.java
@@ -165,17 +165,4 @@ public boolean doesNotCompleteNormally() {
 	public boolean completesByContinue() {
 		return this.statement instanceof ContinueStatement; // NOT this.statement.continuesAtOuterLabel
 	}
-
-	@Override
-	public boolean canCompleteNormally() {
-		if (this.statement.canCompleteNormally())
-			return true;
-		return this.statement.breaksOut(this.label);
-	}
-
-	@Override
-	public boolean continueCompletes() {
-		return this.statement instanceof ContinueStatement; // NOT this.statement.continuesAtOuterLabel
-	}
-
 }
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/LambdaExpression.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/LambdaExpression.java
index 8eadf846dad..90504dd3d53 100644
--- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/LambdaExpression.java
+++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/LambdaExpression.java
@@ -47,9 +47,7 @@
 
 import static org.eclipse.jdt.internal.compiler.ast.ExpressionContext.INVOCATION_CONTEXT;
 
-import java.util.Collections;
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
@@ -80,7 +78,6 @@
 import org.eclipse.jdt.internal.compiler.problem.AbortType;
 import org.eclipse.jdt.internal.compiler.problem.ProblemSeverities;
 
-@SuppressWarnings({"rawtypes", "unchecked"})
 public class LambdaExpression extends FunctionalExpression implements IPolyExpression, ReferenceContext, ProblemSeverities {
 	public Argument [] arguments;
 	private TypeBinding [] argumentTypes;
@@ -101,7 +98,7 @@ public class LambdaExpression extends FunctionalExpression implements IPolyExpre
 	private int outerLocalVariablesSlotSize = 0;
 	private boolean assistNode = false;
 	private ReferenceBinding classType;
-	private Set thrownExceptions;
+	private Set<TypeBinding> thrownExceptions;
 	private static final SyntheticArgumentBinding [] NO_SYNTHETIC_ARGUMENTS = new SyntheticArgumentBinding[0];
 	private static final Block NO_BODY = new Block(0);
 	private HashMap<TypeBinding, LambdaExpression> copiesPerTargetType;
@@ -545,7 +542,7 @@ private void analyzeExceptions() {
 			this.body.analyseCode(this.scope,
 									 ehfc = new ExceptionInferenceFlowContext(null, this, Binding.NO_EXCEPTIONS, null, this.scope, FlowInfo.DEAD_END),
 									 UnconditionalFlowInfo.fakeInitializedFlowInfo(this.firstLocalLocal, this.scope.referenceType().maxFieldCount));
-			this.thrownExceptions = ehfc.extendedExceptions == null ? Collections.emptySet() : new HashSet<TypeBinding>(ehfc.extendedExceptions);
+			this.thrownExceptions = ehfc.extendedExceptions == null ? Set.of() : Set.copyOf(ehfc.extendedExceptions);
 		} catch (Exception e) {
 			// drop silently.
 		} finally {
@@ -1199,7 +1196,7 @@ public void tagAsHavingErrors() {
 
 	public Set<TypeBinding> getThrownExceptions() {
 		if (this.thrownExceptions == null)
-			return Collections.emptySet();
+			return Set.of();
 		return this.thrownExceptions;
 	}
 
@@ -1402,7 +1399,7 @@ public int diagnosticsSourceEnd() {
 
 	public TypeBinding[] getMarkerInterfaces() {
 		if (this.expectedType instanceof IntersectionTypeBinding18) {
-			Set markerBindings = new LinkedHashSet();
+			Set<TypeBinding> markerBindings = new LinkedHashSet<>();
 			IntersectionTypeBinding18 intersectionType = (IntersectionTypeBinding18)this.expectedType;
 			TypeBinding[] intersectionTypes = intersectionType.intersectingTypes;
 			TypeBinding samType = intersectionType.getSAMType(this.enclosingScope);
@@ -1416,7 +1413,7 @@ public TypeBinding[] getMarkerInterfaces() {
 				markerBindings.add(typeBinding);
 			}
 			if (markerBindings.size() > 0) {
-				return (TypeBinding[])markerBindings.toArray(new TypeBinding[markerBindings.size()]);
+				return markerBindings.toArray(TypeBinding[]::new);
 			}
 		}
 		return null;
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/ReturnStatement.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/ReturnStatement.java
index 77bc1e47472..6c20ca42192 100644
--- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/ReturnStatement.java
+++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/ReturnStatement.java
@@ -217,13 +217,8 @@ public boolean doesNotCompleteNormally() {
 	return true;
 }
 
-@Override
-public boolean canCompleteNormally() {
-	return false;
-}
-
 /**
- * Retrun statement code generation
+ * Return statement code generation
  *
  *   generate the finallyInvocationSequence.
  *
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/Statement.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/Statement.java
index a8b1db7c524..e6173aa37cd 100644
--- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/Statement.java
+++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/Statement.java
@@ -104,23 +104,6 @@ public boolean completesByContinue() {
 	return false;
 }
 
-/**
- * Switch Expression analysis: *Assuming* this is reachable, analyze if this completes normally
- *  i.e control flow can reach the textually next statement, as per JLS 14 Sec 14.22
- *  For blocks, we don't perform intra-reachability analysis.
- *  Note: delinking this from a similar (opposite) {@link #doesNotCompleteNormally()} since that was
- *  coded for a specific purpose of Lambda Shape Analysis.
- */
-public boolean canCompleteNormally() {
-	return true;
-}
-/**
- * The equivalent function of completesByContinue - implements both the rules concerning continue with
- * and without a label.
- */
-public boolean continueCompletes() {
-	return false;
-}
 	public static final int NOT_COMPLAINED = 0;
 	public static final int COMPLAINED_FAKE_REACHABLE = 1;
 	public static final int COMPLAINED_UNREACHABLE = 2;
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/SwitchExpression.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/SwitchExpression.java
index 811ebee69d8..53019b7a616 100644
--- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/SwitchExpression.java
+++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/SwitchExpression.java
@@ -376,16 +376,6 @@ private TypeBinding resolveAsType(TypeBinding switchType) {
 	@Override
 	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {
 		flowInfo = super.analyseCode(currentScope, flowContext, flowInfo);
-		if ((this.switchBits & LabeledRules) != 0) { // 15.28.1
-			for (Statement stmt : this.statements) {
-				if (stmt instanceof Block && stmt.canCompleteNormally())
-					currentScope.problemReporter().switchExpressionBlockCompletesNormally(stmt);
-			}
-		} else {
-			Statement ultimateStmt = this.statements[this.statements.length - 1]; // length guaranteed > 0
-			if (ultimateStmt.canCompleteNormally())
-				currentScope.problemReporter().switchExpressionBlockCompletesNormally(ultimateStmt);
-		}
 
 		if (currentScope.compilerOptions().enableSyntacticNullAnalysisForFields)
 			flowContext.expireNullCheckedFieldInfo(); // wipe information that was meant only for this result expression:
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/SwitchStatement.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/SwitchStatement.java
index 10d3b920bbd..fde7a4640d3 100644
--- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/SwitchStatement.java
+++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/SwitchStatement.java
@@ -16,6 +16,7 @@
  *								bug 265744 - Enum switch should warn about missing default
  *								bug 374605 - Unreasonable warning for enum-based switch statements
  *								bug 345305 - [compiler][null] Compiler misidentifies a case of "variable can only be null"
+ *     Advantest R & D - Enhanced Switch v2.0
  *******************************************************************************/
 package org.eclipse.jdt.internal.compiler.ast;
 
@@ -38,6 +39,7 @@
 import org.eclipse.jdt.internal.compiler.codegen.CaseLabel;
 import org.eclipse.jdt.internal.compiler.codegen.CodeStream;
 import org.eclipse.jdt.internal.compiler.codegen.ConstantPool;
+import org.eclipse.jdt.internal.compiler.codegen.Label;
 import org.eclipse.jdt.internal.compiler.codegen.Opcodes;
 import org.eclipse.jdt.internal.compiler.flow.FlowContext;
 import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
@@ -56,7 +58,6 @@
 import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
 import org.eclipse.jdt.internal.compiler.problem.ProblemSeverities;
 
-@SuppressWarnings("rawtypes")
 public class SwitchStatement extends Expression {
 
 	/** Descriptor for a bootstrap method that is created only once but can be used more than once. */
@@ -72,13 +73,16 @@ public static record SingletonBootstrap(String id, char[] selector, char[] signa
 	public Statement[] statements;
 	public BlockScope scope;
 	public int explicitDeclarations;
+	public int blockStart;
 	public BranchLabel breakLabel;
+	private CaseLabel defaultLabel;
+
 
+	public int caseCount; // count of all cases *including* default
 	public CaseStatement[] cases; // all cases *including* default
 	public CaseStatement defaultCase;
 	public CaseStatement nullCase; // convenience pointer for pattern switches
-	public int blockStart;
-	public int caseCount; // count of all cases *including* default
+	public CaseStatement unconditionalPatternCase;
 
 	public static final LabelExpression[] NO_LABEL_EXPRESSIONS = new LabelExpression[0];
 	public LabelExpression[] labelExpressions = NO_LABEL_EXPRESSIONS;
@@ -92,19 +96,19 @@ public static record SingletonBootstrap(String id, char[] selector, char[] signa
 	public boolean containsNull;
 	boolean nullProcessed = false;
 	BranchLabel switchPatternRestartTarget;
-	/* package */ public Pattern totalPattern;
 
 	// fallthrough
 	public final static int CASE = 0;
 	public final static int FALLTHROUGH = 1;
 	public final static int BREAKING  = 2;
 
-	// Other bits
 	public final static int LabeledRules = ASTNode.Bit1;
 	public final static int InvalidSelector = ASTNode.Bit2;
 	public final static int Exhaustive = ASTNode.Bit3;
 	public final static int QualifiedEnum = ASTNode.Bit4;
 	public final static int LabeledBlockStatementGroup = ASTNode.Bit5;
+	public final static int BarricadeInjectedDefault = ASTNode.Bit6;
+	public final static int HasNondefaultCase = ASTNode.Bit7;
 
 	// for switch on strings
 	private static final char[] SecretSelectorVariableName = " selector".toCharArray(); //$NON-NLS-1$
@@ -366,569 +370,6 @@ public boolean visit(TNode node) {
 		}
 	}
 
-	protected boolean needToCheckFlowInAbsenceOfDefaultBranch() {
-		return !this.isExhaustive();
-	}
-	@Override
-	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {
-		try {
-			flowInfo = this.expression.analyseCode(currentScope, flowContext, flowInfo);
-			if (!this.containsNull && this.expression.resolvedType instanceof ReferenceBinding)
-				this.expression.checkNPE(currentScope, flowContext, flowInfo, 1);
-
-			SwitchFlowContext switchContext =
-				new SwitchFlowContext(flowContext, this, (this.breakLabel = new BranchLabel()), true, true);
-
-			CompilerOptions compilerOptions = currentScope.compilerOptions();
-
-			// analyse the block by considering specially the case/default statements (need to bind them
-			// to the entry point)
-			FlowInfo caseInits = FlowInfo.DEAD_END;
-			// in case of statements before the first case
-			this.preSwitchInitStateIndex = currentScope.methodScope().recordInitializationStates(flowInfo);
-			if (this.statements != null) {
-				int initialComplaintLevel = (flowInfo.reachMode() & FlowInfo.UNREACHABLE) != 0 ? Statement.COMPLAINED_FAKE_REACHABLE : Statement.NOT_COMPLAINED;
-				int complaintLevel = initialComplaintLevel;
-				int fallThroughState = CASE;
-				int prevCaseStmtIndex = -100;
-				for (int i = 0, max = this.statements.length; i < max; i++) {
-					Statement statement = this.statements[i];
-					if (statement instanceof CaseStatement caseStatement) {
-						this.scope.enclosingCase = caseStatement; // record entering in a switch case block
-						if (prevCaseStmtIndex == i - 1) {
-							if (this.statements[prevCaseStmtIndex].containsPatternVariable())
-								this.scope.problemReporter().illegalFallthroughFromAPattern(this.statements[prevCaseStmtIndex]);
-						}
-						prevCaseStmtIndex = i;
-						if (fallThroughState == FALLTHROUGH && complaintLevel <= NOT_COMPLAINED) {
-							if (statement.containsPatternVariable())
-								this.scope.problemReporter().IllegalFallThroughToPattern(this.scope.enclosingCase);
-							else if ((statement.bits & ASTNode.DocumentedFallthrough) == 0) // the case is not fall-through protected by a line comment
-								this.scope.problemReporter().possibleFallThroughCase(this.scope.enclosingCase);
-						}
-						caseInits = caseInits.mergedWith(flowInfo.unconditionalInits());
-						if (caseStatement.constantExpressions == NO_EXPRESSIONS) {
-							if ((this.switchBits & LabeledRules) != 0 && this.expression.resolvedType instanceof ReferenceBinding) {
-								if (this.expression instanceof NameReference) {
-									// default case does not apply to null => mark the variable being switched over as nonnull:
-									NameReference reference = (NameReference) this.expression;
-									if (reference.localVariableBinding() != null) {
-										caseInits.markAsDefinitelyNonNull(reference.localVariableBinding());
-									} else if (reference.lastFieldBinding() != null) {
-										if (this.scope.compilerOptions().enableSyntacticNullAnalysisForFields)
-											switchContext.recordNullCheckedFieldReference(reference, 2); // survive this case statement and into the next
-									}
-								} else if (this.expression instanceof FieldReference) {
-									if (this.scope.compilerOptions().enableSyntacticNullAnalysisForFields)
-										switchContext.recordNullCheckedFieldReference((FieldReference) this.expression, 2); // survive this case statement and into the next
-								}
-							}
-						}
-						complaintLevel = initialComplaintLevel; // reset complaint
-						fallThroughState = this.containsPatterns ? FALLTHROUGH : CASE;
-					} else {
-						fallThroughState = (this.switchBits & LabeledRules) != 0 || statement.doesNotCompleteNormally() ? BREAKING : FALLTHROUGH;  // reset below if needed
-					}
-					if ((complaintLevel = statement.complainIfUnreachable(caseInits, this.scope, complaintLevel, true)) < Statement.COMPLAINED_UNREACHABLE) {
-						caseInits = statement.analyseCode(this.scope, switchContext, caseInits);
-						if (compilerOptions.enableSyntacticNullAnalysisForFields)
-							switchContext.expireNullCheckedFieldInfo();
-						if (compilerOptions.analyseResourceLeaks)
-							FakedTrackingVariable.cleanUpUnassigned(this.scope, statement, caseInits, false);
-					}
-				}
-			}
-
-			final TypeBinding resolvedTypeBinding = this.expression.resolvedType;
-			if (resolvedTypeBinding.isEnum()) {
-				final SourceTypeBinding sourceTypeBinding = currentScope.classScope().referenceContext.binding;
-				this.synthetic = sourceTypeBinding.addSyntheticMethodForSwitchEnum(resolvedTypeBinding, this);
-			}
-			// if no default case, then record it may jump over the block directly to the end
-			if (this.defaultCase == null && needToCheckFlowInAbsenceOfDefaultBranch()) {
-				// only retain the potential initializations
-				flowInfo.addPotentialInitializationsFrom(caseInits.mergedWith(switchContext.initsOnBreak));
-				this.mergedInitStateIndex = currentScope.methodScope().recordInitializationStates(flowInfo);
-				return flowInfo;
-			}
-
-			// merge all branches inits
-			FlowInfo mergedInfo = caseInits.mergedWith(switchContext.initsOnBreak);
-			this.mergedInitStateIndex =
-				currentScope.methodScope().recordInitializationStates(mergedInfo);
-			return mergedInfo;
-		} finally {
-			if (this.scope != null) this.scope.enclosingCase = null; // no longer inside switch case block
-		}
-	}
-	/**
-	 * Switch on String code generation
-	 * This assumes that hashCode() specification for java.lang.String is API
-	 * and is stable.
-	 *
-	 * @see "http://download.oracle.com/javase/6/docs/api/java/lang/String.html"
-	 *
-	 * @param currentScope org.eclipse.jdt.internal.compiler.lookup.BlockScope
-	 * @param codeStream org.eclipse.jdt.internal.compiler.codegen.CodeStream
-	 */
-	public void generateCodeForStringSwitch(BlockScope currentScope, CodeStream codeStream) {
-
-		try {
-
-			int pc = codeStream.position;
-
-			class StringSwitchCase implements Comparable {
-				int hashCode;
-				String string;
-				BranchLabel label;
-				public StringSwitchCase(int hashCode, String string, BranchLabel label) {
-					this.hashCode = hashCode;
-					this.string = string;
-					this.label = label;
-				}
-				@Override
-				public int compareTo(Object o) {
-					StringSwitchCase that = (StringSwitchCase) o;
-					if (this.hashCode == that.hashCode) {
-						return 0;
-					}
-					if (this.hashCode > that.hashCode) {
-						return 1;
-					}
-					return -1;
-				}
-				@Override
-				public String toString() {
-					return "StringSwitchCase :\n" + //$NON-NLS-1$
-					       "case " + this.hashCode + ":(" + this.string + ")\n"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-				}
-			}
-			/*
-			 * With multi constant case statements, the number of case statements (hence branch labels)
-			 * and number of constants (hence hashcode labels) could be different. For e.g:
-
-			  switch(s) {
-			  	case "FB", "c":
-			  		System.out.println("A/C");
-			 		break;
-			  	case "Ea":
-					System.out.println("B");
-					break;
-
-				With the above code, we will have
-				2 branch labels for FB and c
-				3 stringCases for FB, c and Ea
-				2 hashCodeCaseLabels one for FB, Ea and one for c
-
-				Should produce something like this:
-				lookupswitch  { // 2
-                      99: 32
-                    2236: 44
-                 default: 87
-
-				"FB" and "Ea" producing the same hashcode values, but still belonging in different case statements.
-				First, produce the two branch labels pertaining to the case statements
-				And the three string cases.
-			 */
-			final boolean hasCases = this.caseCount > 1 || (this.caseCount == 1 && this.defaultCase == null);
-			int constSize = hasCases ? this.labelExpressions.length : 0;
-			BranchLabel[] sourceCaseLabels = this.<BranchLabel>gatherLabels(codeStream, new BranchLabel[this.nConstants], BranchLabel::new);
-			StringSwitchCase [] stringCases = new StringSwitchCase[constSize]; // may have to shrink later if multiple strings hash to same code.
-			CaseLabel [] hashCodeCaseLabels = new CaseLabel[constSize];
-			int [] hashCodes = new int[constSize];
-			for (int i = 0; i < constSize; i++) {
-				String literal = this.labelExpressions[i].constant.stringValue();
-				stringCases[i] = new StringSwitchCase(literal.hashCode(), literal, sourceCaseLabels[i]);
-				hashCodeCaseLabels[i] = new CaseLabel(codeStream);
-				hashCodeCaseLabels[i].tagBits |= BranchLabel.USED;
-			}
-			Arrays.sort(stringCases);
-
-			int uniqHashCount = 0;
-			int lastHashCode = 0;
-			for (int i = 0, length = constSize; i < length; ++i) {
-				int hashCode = stringCases[i].hashCode;
-				if (i == 0 || hashCode != lastHashCode) {
-					lastHashCode = hashCodes[uniqHashCount++] = hashCode;
-				}
-			}
-
-			if (uniqHashCount != constSize) { // multiple keys hashed to the same value.
-				System.arraycopy(hashCodes, 0, hashCodes = new int[uniqHashCount], 0, uniqHashCount);
-				System.arraycopy(hashCodeCaseLabels, 0, hashCodeCaseLabels = new CaseLabel[uniqHashCount], 0, uniqHashCount);
-			}
-			int[] sortedIndexes = new int[uniqHashCount]; // hash code are sorted already anyways.
-			for (int i = 0; i < uniqHashCount; i++) {
-				sortedIndexes[i] = i;
-			}
-
-			CaseLabel defaultCaseLabel = new CaseLabel(codeStream);
-			defaultCaseLabel.tagBits |= BranchLabel.USED;
-
-			// prepare the labels and constants
-			this.breakLabel.initialize(codeStream);
-
-			BranchLabel defaultBranchLabel = new BranchLabel(codeStream);
-			if (hasCases) defaultBranchLabel.tagBits |= BranchLabel.USED;
-			if (this.defaultCase != null) {
-				this.defaultCase.targetLabel = defaultBranchLabel;
-			}
-			// generate expression
-			this.expression.generateCode(currentScope, codeStream, true);
-			codeStream.store(this.selector, true);  // leaves string on operand stack
-			codeStream.addVariable(this.selector);
-			codeStream.invokeStringHashCode();
-			if (hasCases) {
-				codeStream.lookupswitch(defaultCaseLabel, hashCodes, sortedIndexes, hashCodeCaseLabels);
-				for (int i = 0, j = 0, max = constSize; i < max; i++) {
-					int hashCode = stringCases[i].hashCode;
-					if (i == 0 || hashCode != lastHashCode) {
-						lastHashCode = hashCode;
-						if (i != 0) {
-							codeStream.goto_(defaultBranchLabel);
-						}
-						hashCodeCaseLabels[j++].place();
-					}
-					codeStream.load(this.selector);
-					codeStream.ldc(stringCases[i].string);
-					codeStream.invokeStringEquals();
-					codeStream.ifne(stringCases[i].label);
-				}
-				codeStream.goto_(defaultBranchLabel);
-			} else {
-				codeStream.pop();
-			}
-
-			// generate the switch block statements
-			if (this.statements != null) {
-				for (Statement statement : this.statements) {
-					if (statement instanceof CaseStatement caseStatement) {
-						this.scope.enclosingCase = caseStatement; // record entering in a switch case block
-						if (this.preSwitchInitStateIndex != -1)
-							codeStream.removeNotDefinitelyAssignedVariables(currentScope, this.preSwitchInitStateIndex);
-						if (statement == this.defaultCase)
-							defaultCaseLabel.place(); // branch label gets placed by generateCode below.
-					}
-				    statement.generateCode(this.scope, codeStream);
-				    if ((this.switchBits & LabeledRules) != 0 && statement instanceof Block && statement.canCompleteNormally())
-						codeStream.goto_(this.breakLabel);
-				}
-			}
-
-			// May loose some local variable initializations : affecting the local variable attributes
-			if (this.mergedInitStateIndex != -1) {
-				codeStream.removeNotDefinitelyAssignedVariables(currentScope, this.mergedInitStateIndex);
-				codeStream.addDefinitelyAssignedVariables(currentScope, this.mergedInitStateIndex);
-			}
-			codeStream.removeVariable(this.selector);
-			if (this.scope != currentScope) {
-				codeStream.exitUserScope(this.scope);
-			}
-			// place the trailing labels (for break and default case)
-			this.breakLabel.place();
-			if (this.defaultCase == null) {
-				// we want to force an line number entry to get an end position after the switch statement
-				codeStream.recordPositionsFrom(codeStream.position, this.sourceEnd, true);
-				defaultCaseLabel.place();
-				defaultBranchLabel.place();
-			}
-			codeStream.recordPositionsFrom(pc, this.sourceStart);
-		} finally {
-			if (this.scope != null) this.scope.enclosingCase = null; // no longer inside switch case block
-		}
-	}
-	private <T extends BranchLabel>T[] gatherLabels(CodeStream codeStream, T[] caseLabels,
-			Function<CodeStream, T> newLabel)
-	{
-		for (int i = 0, j = 0, max = this.caseCount; i < max; i++) {
-			CaseStatement stmt = this.cases[i];
-			final Expression[] peeledLabelExpressions = stmt.peeledLabelExpressions();
-			int length = peeledLabelExpressions.length;
-			BranchLabel[] targetLabels = new BranchLabel[length];
-			int count = 0;
-			for (int k = 0; k < length; ++k) {
-				Expression e = peeledLabelExpressions[k];
-				if (e instanceof FakeDefaultLiteral) continue;
-				targetLabels[count++] = (caseLabels[j] = newLabel.apply(codeStream));
-				if (e == this.totalPattern)
-					this.defaultCase = stmt;
-				caseLabels[j++].tagBits |= BranchLabel.USED;
-			}
-			System.arraycopy(targetLabels, 0, stmt.targetLabels = new BranchLabel[count], 0, count);
-		}
-		return caseLabels;
-	}
-	/**
-	 * Switch code generation
-	 *
-	 * @param currentScope org.eclipse.jdt.internal.compiler.lookup.BlockScope
-	 * @param codeStream org.eclipse.jdt.internal.compiler.codegen.CodeStream
-	 */
-	@Override
-	public void generateCode(BlockScope currentScope, CodeStream codeStream) {
-		if ((this.bits & IsReachable) == 0)
-			return;
-
-		if (this.expression.resolvedType.id == TypeIds.T_JavaLangString && !this.isNonTraditional) {
-			generateCodeForStringSwitch(currentScope, codeStream);
-			return;
-		}
-
-		try {
-			int pc = codeStream.position;
-			// prepare the labels and constants
-			this.breakLabel.initialize(codeStream);
-			CaseLabel[] caseLabels = this.<CaseLabel>gatherLabels(codeStream, new CaseLabel[this.nConstants], CaseLabel::new);
-
-			CaseLabel defaultLabel = new CaseLabel(codeStream);
-			final boolean hasCases = this.caseCount > 1 || (this.caseCount == 1 && this.defaultCase == null);
-			if (hasCases) defaultLabel.tagBits |= BranchLabel.USED;
-			if (this.defaultCase != null) {
-				this.defaultCase.targetLabel = defaultLabel;
-			}
-
-			final TypeBinding resolvedType1 = this.expression.resolvedType;
-			boolean valueRequired = false;
-			int constantCount = this.labelExpressions.length;
-			int [] constants = new int[constantCount];
-			if (needPatternDispatchCopy()) {
-				generateCodeSwitchPatternPrologue(currentScope, codeStream);
-				valueRequired = true;
-				for (int i = 0, j = 0, length = this.labelExpressions.length; i < length; ++i) {
-					if (this.nullCase == null && this.labelExpressions[i].expression == this.totalPattern)
-						this.labelExpressions[i].index = -1;
-					constants[i] = this.labelExpressions[i].index - j;
-					if (this.labelExpressions[i].expression instanceof NullLiteral)
-						j = 1;  // since we yank null out to -1, shift down everything beyond.
-				}
-			} else {
-				for (int i = 0, length = this.labelExpressions.length; i < length; ++i)
-					constants[i] = this.labelExpressions[i].intValue();
-				if (resolvedType1.isEnum()) {
-					// go through the translation table
-					codeStream.invoke(Opcodes.OPC_invokestatic, this.synthetic, null /* default declaringClass */);
-					this.expression.generateCode(currentScope, codeStream, true);
-					// get enum constant ordinal()
-					codeStream.invokeEnumOrdinal(resolvedType1.constantPoolName());
-					codeStream.iaload();
-					if (!hasCases) {
-						// we can get rid of the generated ordinal value
-						codeStream.pop();
-					}
-					valueRequired = hasCases;
-				} else {
-					valueRequired = this.expression.constant == Constant.NotAConstant || hasCases;
-					// generate expression
-					this.expression.generateCode(currentScope, codeStream, valueRequired);
-					if (resolvedType1.id == TypeIds.T_JavaLangBoolean) {
-						codeStream.generateUnboxingConversion(TypeIds.T_boolean); // optimize by avoiding indy
-																					// typeSwitch
-					}
-				}
-			}
-			// generate the appropriate switch table/lookup bytecode
-			if (hasCases) {
-				int[] sortedIndexes = new int[constantCount];
-				// we sort the keys to be able to generate the code for tableswitch or lookupswitch
-				for (int i = 0; i < constantCount; i++) {
-					sortedIndexes[i] = i;
-				}
-				int[] localKeysCopy;
-				System.arraycopy(constants, 0, (localKeysCopy = new int[constantCount]), 0, constantCount);
-				CodeStream.sort(localKeysCopy, 0, constantCount - 1, sortedIndexes);
-
-				int max = localKeysCopy[constantCount - 1];
-				int min = localKeysCopy[0];
-				if ((long) (constantCount * 2.5) > ((long) max - (long) min)) {
-						codeStream.tableswitch(
-							defaultLabel,
-							min,
-							max,
-							constants,
-							sortedIndexes,
-							caseLabels);
-				} else {
-					codeStream.lookupswitch(defaultLabel, constants, sortedIndexes, caseLabels);
-				}
-				codeStream.recordPositionsFrom(codeStream.position, this.expression.sourceEnd);
-			} else if (valueRequired) {
-				codeStream.pop();
-			}
-
-			// generate the switch block statements
-			if (this.statements != null) {
-				for (Statement statement : this.statements) {
-					if (statement instanceof CaseStatement caseStatement) {
-						this.scope.enclosingCase = caseStatement; // record entering in a switch case block
-						if (this.preSwitchInitStateIndex != -1)
-							codeStream.removeNotDefinitelyAssignedVariables(currentScope, this.preSwitchInitStateIndex);
-					}
-					statement.generateCode(this.scope, codeStream);
-					if ((this.switchBits & LabeledRules) != 0 && statement instanceof Block && statement.canCompleteNormally())
-						codeStream.goto_(this.breakLabel);
-				}
-			}
-			boolean needsThrowingDefault = false;
-			if (this.defaultCase == null) {
-				// enum:
-				needsThrowingDefault = resolvedType1.isEnum() && (this instanceof SwitchExpression || this.containsNull);
-				// pattern switches:
-				needsThrowingDefault |= isExhaustive();
-			}
-			if (needsThrowingDefault) {
-				// we want to force an line number entry to get an end position after the switch statement
-				if (this.preSwitchInitStateIndex != -1) {
-					codeStream.removeNotDefinitelyAssignedVariables(currentScope, this.preSwitchInitStateIndex);
-				}
-				/* a default case is not needed for an exhaustive switch expression
-				 * we need to handle the default case to throw an error in order to make the stack map consistent.
-				 * All cases will return a value on the stack except the missing default case.
-				 * There is no returned value for the default case so we handle it with an exception thrown.
-				 */
-				if (this.scope.compilerOptions().complianceLevel >= ClassFileConstants.JDK19) {
-					// since 19 we have MatchException for this
-					if (this.statements.length > 0 && this.statements[this.statements.length - 1].canCompleteNormally())
-						codeStream.goto_(this.breakLabel); // hop, skip and jump over match exception throw.
-					defaultLabel.place();
-					codeStream.newJavaLangMatchException();
-					codeStream.dup();
-					codeStream.aconst_null();
-					codeStream.aconst_null();
-					codeStream.invokeJavaLangMatchExceptionConstructor();
-					codeStream.athrow();
-				} else {
-					// old style using IncompatibleClassChangeError:
-					defaultLabel.place();
-					codeStream.newJavaLangIncompatibleClassChangeError();
-					codeStream.dup();
-					codeStream.invokeJavaLangIncompatibleClassChangeErrorDefaultConstructor();
-					codeStream.athrow();
-				}
-			}
-			// May loose some local variable initializations : affecting the local variable attributes
-			if (this.mergedInitStateIndex != -1) {
-				codeStream.removeNotDefinitelyAssignedVariables(currentScope, this.mergedInitStateIndex);
-				codeStream.addDefinitelyAssignedVariables(currentScope, this.mergedInitStateIndex);
-			}
-			generateCodeSwitchPatternEpilogue(codeStream);
-			if (this.scope != currentScope)
-				codeStream.exitUserScope(this.scope);
-			// place the trailing labels (for break and default case)
-			this.breakLabel.place();
-			if (this.defaultCase == null && !needsThrowingDefault) {
-				// we want to force an line number entry to get an end position after the switch statement
-				codeStream.recordPositionsFrom(codeStream.position, this.sourceEnd, true);
-				defaultLabel.place();
-			}
-			codeStream.recordPositionsFrom(pc, this.sourceStart);
-		} finally {
-			if (this.scope != null) this.scope.enclosingCase = null; // no longer inside switch case block
-		}
-	}
-
-	private void generateCodeSwitchPatternEpilogue(CodeStream codeStream) {
-		if (needPatternDispatchCopy())
-			codeStream.removeVariable(this.selector);
-	}
-
-	private void generateCodeSwitchPatternPrologue(BlockScope currentScope, CodeStream codeStream) {
-		this.expression.generateCode(currentScope, codeStream, true);
-		if (!this.containsNull && !this.expression.resolvedType.isPrimitiveType()) {
-			codeStream.dup();
-			codeStream.invokeJavaUtilObjectsrequireNonNull();
-			codeStream.pop();
-		}
-
-		codeStream.store(this.selector, false);
-		codeStream.addVariable(this.selector);
-
-		int invokeDynamicNumber = codeStream.classFile.recordBootstrapMethod(this);
-
-		codeStream.load(this.selector);
-		codeStream.loadInt(0); // restartIndex
-		this.switchPatternRestartTarget = new BranchLabel(codeStream);
-		this.switchPatternRestartTarget.place();
-
-		if (this.expression.resolvedType.isEnum())
-			generateEnumSwitchPatternPrologue(codeStream, invokeDynamicNumber);
-		else
-			generateTypeSwitchPatternPrologue(codeStream, invokeDynamicNumber);
-
-		boolean hasQualifiedEnums = (this.switchBits & QualifiedEnum) != 0;
-		for (int i = 0; i < this.labelExpressions.length; i++) {
-			LabelExpression c = this.labelExpressions[i];
-			if (hasQualifiedEnums)
-				c.index = i;
-			if (c.type.isPrimitiveType()) {
-				SingletonBootstrap descriptor = c.isPattern() ? PRIMITIVE_CLASS__BOOTSTRAP : c.type.id == TypeIds.T_boolean ? GET_STATIC_FINAL__BOOTSTRAP : null;
-				if (descriptor != null)
-					c.primitivesBootstrapIdx = codeStream.classFile.recordSingletonBootstrapMethod(descriptor);
-				continue;
-			}
-			if (c.isQualifiedEnum()) {
-				c.enumDescIdx = codeStream.classFile.recordBootstrapMethod(c);
-				c.classDescIdx = codeStream.classFile.recordBootstrapMethod(c.type);
-			}
-		}
-	}
-	private void generateTypeSwitchPatternPrologue(CodeStream codeStream, int invokeDynamicNumber) {
-		TypeBinding exprType = this.expression.resolvedType;
-		char[] signature = typeSwitchSignature(exprType);
-		int argsSize = TypeIds.getCategory(exprType.id) + 1; // Object | PRIM, restartIndex (PRIM = Z|S|I..)
-		codeStream.invokeDynamic(invokeDynamicNumber,
-				argsSize,
-				1, // int
-				ConstantPool.TYPESWITCH,
-				signature,
-				TypeBinding.INT);
-	}
-	char[] typeSwitchSignature(TypeBinding exprType) {
-		char[] arg1 = switch (exprType.id) {
-			case TypeIds.T_JavaLangLong, TypeIds.T_JavaLangFloat, TypeIds.T_JavaLangDouble, TypeIds.T_JavaLangBoolean,
-				TypeIds.T_JavaLangByte, TypeIds.T_JavaLangShort, TypeIds.T_JavaLangInteger, TypeIds.T_JavaLangCharacter->
-				this.isPrimitiveSwitch
-				? exprType.signature()
-				: "Ljava/lang/Object;".toCharArray(); //$NON-NLS-1$
-			default -> {
-				if (exprType.id > TypeIds.T_LastWellKnownTypeId && exprType.erasure().isBoxedPrimitiveType())
-					yield exprType.erasure().signature(); // <T extends Integer> / <? extends Short> ...
-				else
-					yield exprType.isPrimitiveType()
-						? exprType.signature()
-						: "Ljava/lang/Object;".toCharArray(); //$NON-NLS-1$
-			}
-		};
-		return CharOperation.concat("(".toCharArray(), arg1, "I)I".toCharArray()); //$NON-NLS-1$ //$NON-NLS-2$
-	}
-	private void generateEnumSwitchPatternPrologue(CodeStream codeStream, int invokeDynamicNumber) {
-		String genericTypeSignature = new String(this.expression.resolvedType.genericTypeSignature());
-		String callingParams = "(" + genericTypeSignature + "I)I"; //$NON-NLS-1$ //$NON-NLS-2$
-		codeStream.invokeDynamic(invokeDynamicNumber,
-				2, // Object, restartIndex
-				1, // int
-				"enumSwitch".toCharArray(), //$NON-NLS-1$
-				callingParams.toCharArray(),
-				TypeBinding.INT);
-	}
-
-	@Override
-	public StringBuilder printStatement(int indent, StringBuilder output) {
-
-		printIndent(indent, output).append("switch ("); //$NON-NLS-1$
-		this.expression.printExpression(0, output).append(") {"); //$NON-NLS-1$
-		if (this.statements != null) {
-			for (Statement statement : this.statements) {
-				output.append('\n');
-				if (statement instanceof CaseStatement)
-					statement.printStatement(indent, output);
-				else
-					statement.printStatement(indent+2, output);
-			}
-		}
-		output.append("\n"); //$NON-NLS-1$
-		return printIndent(indent, output).append('}');
-	}
-
 	private void preprocess() {
 		int n = 0;
 		for (final Statement statement : this.statements) {
@@ -1014,83 +455,7 @@ void gatherLabelExpression(LabelExpression labelExpression) {
 		this.labelExpressions[this.labelExpressionIndex++] = labelExpression;
 	}
 
-
-	@Override
-	public void resolve(BlockScope upperScope) {
-		try {
-			TypeBinding expressionType = this.expression.resolveType(upperScope);
-			if (expressionType != null && !expressionType.isValidBinding())
-				expressionType = null; // fault-tolerance: ignore further type mismatch from label expressions
-			CompilerOptions compilerOptions = upperScope.compilerOptions();
-			if (expressionType != null) {
-				this.expression.computeConversion(upperScope, expressionType, expressionType);
-				checkType: {
-					if (expressionType.isBaseType()) {
-						if (JavaFeature.PRIMITIVES_IN_PATTERNS.isSupported(compilerOptions))
-							this.isPrimitiveSwitch = true;
-						if (this.expression.isConstantValueOfTypeAssignableToType(expressionType, TypeBinding.INT))
-							break checkType;
-						if (expressionType.isCompatibleWith(TypeBinding.INT))
-							break checkType;
-					}
-					if (expressionType.id == TypeIds.T_JavaLangString || expressionType.isEnum() || upperScope.isBoxingCompatibleWith(expressionType, TypeBinding.INT))
-						break checkType;
-					if (JavaFeature.PATTERN_MATCHING_IN_SWITCH.isSupported(compilerOptions) && (!expressionType.isBaseType() || expressionType.id == T_null || expressionType.id == T_void)) {
-						this.isNonTraditional = true;
-					} else {
-						if (!this.isPrimitiveSwitch) { // when isPrimitiveSwitch is set it is approved above
-							upperScope.problemReporter().incorrectSwitchType(this.expression, expressionType);
-							expressionType = null; // fault-tolerance: ignore type mismatch from constants from hereon
-						}
-					}
-				}
-			}
-
-			this.scope = new BlockScope(upperScope);
-			if (expressionType != null)
-				reserveSecretVariablesSlot();
-			else
-				this.switchBits |= InvalidSelector;
-
-			if (this.statements != null) {
-				preprocess(); // make a pass over the switch block and allocate vectors.
-				LocalVariableBinding[] patternVariables = NO_VARIABLES;
-				for (final Statement statement : this.statements) {
-					if (statement instanceof CaseStatement caseStatement) {
-						caseStatement.swich = this;
-						caseStatement.resolve(this.scope);
-						patternVariables = caseStatement.bindingsWhenTrue();
-					} else {
-						statement.resolveWithBindings(patternVariables, this.scope);
-						patternVariables = LocalVariableBinding.merge(patternVariables, statement.bindingsWhenComplete());
-					}
-				}
-				if (expressionType != null
-						&& (expressionType.id == TypeIds.T_boolean || expressionType.id == TypeIds.T_JavaLangBoolean)
-						&& this.defaultCase != null  && isExhaustive()) {
-					upperScope.problemReporter().caseDefaultPlusTrueAndFalse(this);
-				}
-				if (this.labelExpressions.length != this.labelExpressionIndex)
-					System.arraycopy(this.labelExpressions, 0, this.labelExpressions = new LabelExpression[this.labelExpressionIndex], 0, this.labelExpressionIndex);
-			} else {
-				if ((this.bits & UndocumentedEmptyBlock) != 0)
-					upperScope.problemReporter().undocumentedEmptyBlock(this.blockStart, this.sourceEnd);
-			}
-
-			if (expressionType != null) {
-				if (!expressionType.isBaseType() && upperScope.isBoxingCompatibleWith(expressionType, TypeBinding.INT)) {
-					if (!this.containsPatterns && !this.containsNull)
-						this.expression.computeConversion(upperScope, TypeBinding.INT, expressionType);
-				}
-				releaseUnusedSecretVariable();
-				complainIfNotExhaustiveSwitch(upperScope, expressionType, compilerOptions);
-			}
-
-		} finally {
-			if (this.scope != null) this.scope.enclosingCase = null; // no longer inside switch case block
-		}
-	}
-	private void complainIfNotExhaustiveSwitch(BlockScope upperScope, TypeBinding selectorType, CompilerOptions compilerOptions) {
+	private void complainIfNotExhaustiveSwitch(BlockScope upperScope, TypeBinding selectorType, CompilerOptions compilerOptions) {
 
 		boolean isEnhanced = isEnhancedSwitch(upperScope, selectorType);
 		if (selectorType != null && selectorType.isEnum()) {
@@ -1104,7 +469,7 @@ private void complainIfNotExhaustiveSwitch(BlockScope upperScope, TypeBinding se
 				casesCount--; // discount the default
 
 			int constantCount = this.labelExpressions == null ? 0 : this.labelExpressions.length;
-			if (!(this.totalPattern != null) &&
+			if (!(this.unconditionalPatternCase != null) &&
 					((this.containsPatterns || this.containsNull) ||
 					(constantCount >= casesCount &&
 					constantCount != ((ReferenceBinding)selectorType).enumConstantCount()))) {
@@ -1267,22 +632,6 @@ private boolean caseElementsCoverSealedType(ReferenceBinding sealedType,  List<T
 		}
 		return allAllowedTypes.size() == 0;
 	}
-	private boolean needPatternDispatchCopy() {
-		if (this.containsPatterns || this.containsNull || (this.switchBits & QualifiedEnum) != 0)
-			return true;
-		TypeBinding eType = this.expression.resolvedType;
-		if (eType == null)
-			return false;
-		switch (eType.id) {
-			case TypeIds.T_JavaLangLong, TypeIds.T_JavaLangFloat, TypeIds.T_JavaLangDouble:
-				return true;
-			case TypeIds.T_long, TypeIds.T_double, TypeIds.T_float :
-				if (this.isPrimitiveSwitch)
-					return true;
-			// note: if no patterns are present we optimize Boolean to use unboxing rather than indy typeSwitch
-		}
-		return !(eType.isPrimitiveOrBoxedPrimitiveType() || eType.isEnum() || eType.id == TypeIds.T_JavaLangString); // classic selectors
-	}
 
 	private void reserveSecretVariablesSlot() { // may be released later if unused.
 		this.selector  = new LocalVariableBinding(SecretSelectorVariableName, this.scope.getJavaLangObject(), ClassFileConstants.AccDefault, false);
@@ -1298,28 +647,107 @@ private void releaseUnusedSecretVariable() {
 			} else if (needPatternDispatchCopy()) {
 				this.selector.useFlag = LocalVariableBinding.USED;
 			    this.selector.type = this.expression.resolvedType;
-			} // else gets released by virtue of not being tagged USED.
+			} else {
+				this.selector = null;
+			}
 		}
 	}
-	protected void reportMissingEnumConstantCase(BlockScope upperScope, FieldBinding enumConstant) {
-		upperScope.problemReporter().missingEnumConstantCase(this, enumConstant);
-	}
-	@Override
-	public boolean isTrulyExpression() {
-		return false;
+
+	private boolean needPatternDispatchCopy() {
+		if (this.containsPatterns || this.containsNull || (this.switchBits & QualifiedEnum) != 0)
+			return true;
+		TypeBinding eType = this.expression.resolvedType;
+		if (eType == null)
+			return false;
+		switch (eType.id) {
+			case TypeIds.T_JavaLangLong, TypeIds.T_JavaLangFloat, TypeIds.T_JavaLangDouble:
+				return true;
+			case TypeIds.T_long, TypeIds.T_double, TypeIds.T_float :
+				if (this.isPrimitiveSwitch)
+					return true;
+			// note: if no patterns are present we optimize Boolean to use unboxing rather than indy typeSwitch
+		}
+		return !(eType.isPrimitiveOrBoxedPrimitiveType() || eType.isEnum() || eType.id == TypeIds.T_JavaLangString); // classic selectors
 	}
 
 	@Override
-	public void traverse(ASTVisitor visitor, BlockScope blockScope) {
-		if (visitor.visit(this, blockScope)) {
-			this.expression.traverse(visitor, blockScope);
+	public void resolve(BlockScope upperScope) {
+		try {
+			TypeBinding expressionType = this.expression.resolveType(upperScope);
+			if (expressionType != null && !expressionType.isValidBinding())
+				expressionType = null; // fault-tolerance: ignore further type mismatch from label expressions
+			CompilerOptions compilerOptions = upperScope.compilerOptions();
+			if (expressionType != null) {
+				this.expression.computeConversion(upperScope, expressionType, expressionType);
+				checkType: {
+					if (expressionType.isBaseType()) {
+						if (JavaFeature.PRIMITIVES_IN_PATTERNS.isSupported(compilerOptions))
+							this.isPrimitiveSwitch = true;
+						if (this.expression.isConstantValueOfTypeAssignableToType(expressionType, TypeBinding.INT))
+							break checkType;
+						if (expressionType.isCompatibleWith(TypeBinding.INT))
+							break checkType;
+					}
+					if (expressionType.id == TypeIds.T_JavaLangString || expressionType.isEnum() || upperScope.isBoxingCompatibleWith(expressionType, TypeBinding.INT))
+						break checkType;
+					if (JavaFeature.PATTERN_MATCHING_IN_SWITCH.isSupported(compilerOptions) && (!expressionType.isBaseType() || expressionType.id == T_null || expressionType.id == T_void)) {
+						this.isNonTraditional = true;
+					} else {
+						if (!this.isPrimitiveSwitch) { // when isPrimitiveSwitch is set it is approved above
+							upperScope.problemReporter().incorrectSwitchType(this.expression, expressionType);
+							expressionType = null; // fault-tolerance: ignore type mismatch from constants from hereon
+						}
+					}
+				}
+			}
+
+			this.scope = new BlockScope(upperScope);
+			if (expressionType != null)
+				reserveSecretVariablesSlot();
+			else
+				this.switchBits |= InvalidSelector;
+
 			if (this.statements != null) {
-				int statementsLength = this.statements.length;
-				for (int i = 0; i < statementsLength; i++)
-					this.statements[i].traverse(visitor, this.scope);
+				preprocess(); // make a pass over the switch block and allocate vectors.
+				LocalVariableBinding[] patternVariables = NO_VARIABLES;
+				for (final Statement statement : this.statements) {
+					if (statement instanceof CaseStatement caseStatement) {
+						caseStatement.swich = this;
+						caseStatement.resolve(this.scope);
+						patternVariables = caseStatement.bindingsWhenTrue();
+					} else {
+						statement.resolveWithBindings(patternVariables, this.scope);
+						patternVariables = LocalVariableBinding.merge(patternVariables, statement.bindingsWhenComplete());
+					}
+				}
+				if (expressionType != null
+						&& (expressionType.id == TypeIds.T_boolean || expressionType.id == TypeIds.T_JavaLangBoolean)
+						&& this.defaultCase != null  && isExhaustive()) {
+					upperScope.problemReporter().caseDefaultPlusTrueAndFalse(this);
+				}
+				if (this.labelExpressions.length != this.labelExpressionIndex)
+					System.arraycopy(this.labelExpressions, 0, this.labelExpressions = new LabelExpression[this.labelExpressionIndex], 0, this.labelExpressionIndex);
+			} else {
+				if ((this.bits & UndocumentedEmptyBlock) != 0)
+					upperScope.problemReporter().undocumentedEmptyBlock(this.blockStart, this.sourceEnd);
+			}
+
+			if (expressionType != null) {
+				if (!expressionType.isBaseType() && upperScope.isBoxingCompatibleWith(expressionType, TypeBinding.INT)) {
+					if (!this.containsPatterns && !this.containsNull)
+						this.expression.computeConversion(upperScope, TypeBinding.INT, expressionType);
+				}
+				releaseUnusedSecretVariable();
+				complainIfNotExhaustiveSwitch(upperScope, expressionType, compilerOptions);
 			}
+
+		} finally {
+			if (this.scope != null) this.scope.enclosingCase = null; // no longer inside switch case block
 		}
-		visitor.endVisit(this, blockScope);
+	}
+
+	protected void reportMissingEnumConstantCase(BlockScope upperScope, FieldBinding enumConstant) {
+		upperScope.problemReporter().missingEnumConstantCase(this, enumConstant);
 	}
 
 	/**
@@ -1338,6 +766,463 @@ public void branchChainTo(BranchLabel label) {
 		}
 	}
 
+	protected boolean needToCheckFlowInAbsenceOfDefaultBranch() {
+		return !this.isExhaustive();
+	}
+
+	@Override
+	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {
+		try {
+			flowInfo = this.expression.analyseCode(currentScope, flowContext, flowInfo);
+			if (!this.containsNull && this.expression.resolvedType instanceof ReferenceBinding)
+				this.expression.checkNPE(currentScope, flowContext, flowInfo, 1);
+
+			SwitchFlowContext switchContext =
+				new SwitchFlowContext(flowContext, this, (this.breakLabel = new BranchLabel()), true, true);
+
+			CompilerOptions compilerOptions = currentScope.compilerOptions();
+
+			// analyse the block by considering specially the case/default statements (need to bind them
+			// to the entry point)
+			FlowInfo caseInits = FlowInfo.DEAD_END;
+			// in case of statements before the first case
+			this.preSwitchInitStateIndex = currentScope.methodScope().recordInitializationStates(flowInfo);
+			if (this.statements != null) {
+				int initialComplaintLevel = (flowInfo.reachMode() & FlowInfo.UNREACHABLE) != 0 ? Statement.COMPLAINED_FAKE_REACHABLE : Statement.NOT_COMPLAINED;
+				int complaintLevel = initialComplaintLevel;
+				int fallThroughState = CASE;
+				int prevCaseStmtIndex = -100;
+				for (int i = 0, max = this.statements.length; i < max; i++) {
+					Statement statement = this.statements[i];
+					if (statement instanceof CaseStatement caseStatement) {
+						this.scope.enclosingCase = caseStatement; // record entering in a switch case block
+						if (prevCaseStmtIndex == i - 1) {
+							if (this.statements[prevCaseStmtIndex].containsPatternVariable())
+								this.scope.problemReporter().illegalFallthroughFromAPattern(this.statements[prevCaseStmtIndex]);
+						}
+						prevCaseStmtIndex = i;
+						if (fallThroughState == FALLTHROUGH && complaintLevel <= NOT_COMPLAINED) {
+							if (statement.containsPatternVariable())
+								this.scope.problemReporter().IllegalFallThroughToPattern(this.scope.enclosingCase);
+							else if ((statement.bits & ASTNode.DocumentedFallthrough) == 0) // the case is not fall-through protected by a line comment
+								this.scope.problemReporter().possibleFallThroughCase(this.scope.enclosingCase);
+						}
+						caseInits = caseInits.mergedWith(flowInfo.unconditionalInits());
+						if (caseStatement.constantExpressions == NO_EXPRESSIONS) {
+							if ((this.switchBits & LabeledRules) != 0 && this.expression.resolvedType instanceof ReferenceBinding) {
+								if (this.expression instanceof NameReference) {
+									// default case does not apply to null => mark the variable being switched over as nonnull:
+									NameReference reference = (NameReference) this.expression;
+									if (reference.localVariableBinding() != null) {
+										caseInits.markAsDefinitelyNonNull(reference.localVariableBinding());
+									} else if (reference.lastFieldBinding() != null) {
+										if (this.scope.compilerOptions().enableSyntacticNullAnalysisForFields)
+											switchContext.recordNullCheckedFieldReference(reference, 2); // survive this case statement and into the next
+									}
+								} else if (this.expression instanceof FieldReference) {
+									if (this.scope.compilerOptions().enableSyntacticNullAnalysisForFields)
+										switchContext.recordNullCheckedFieldReference((FieldReference) this.expression, 2); // survive this case statement and into the next
+								}
+							}
+						}
+						complaintLevel = initialComplaintLevel; // reset complaint
+						fallThroughState = this.containsPatterns ? FALLTHROUGH : CASE;
+					} else {
+						fallThroughState = (this.switchBits & LabeledRules) != 0 || statement.doesNotCompleteNormally() ? BREAKING : FALLTHROUGH;  // reset below if needed
+					}
+					if ((complaintLevel = statement.complainIfUnreachable(caseInits, this.scope, complaintLevel, true)) < Statement.COMPLAINED_UNREACHABLE) {
+						caseInits = statement.analyseCode(this.scope, switchContext, caseInits);
+						if (compilerOptions.enableSyntacticNullAnalysisForFields)
+							switchContext.expireNullCheckedFieldInfo();
+						if (compilerOptions.analyseResourceLeaks)
+							FakedTrackingVariable.cleanUpUnassigned(this.scope, statement, caseInits, false);
+					}
+				}
+			}
+			if (caseInits != FlowInfo.DEAD_END) {
+				if (isTrulyExpression())
+					currentScope.problemReporter().switchExpressionBlockCompletesNormally(this.statements[this.statements.length - 1]);
+				if (this.defaultCase == null)
+					this.switchBits |= BarricadeInjectedDefault;
+			}
+
+			final TypeBinding resolvedTypeBinding = this.expression.resolvedType;
+			if (resolvedTypeBinding.isEnum() && !needPatternDispatchCopy()) {
+				final SourceTypeBinding sourceTypeBinding = currentScope.classScope().referenceContext.binding;
+				this.synthetic = sourceTypeBinding.addSyntheticMethodForSwitchEnum(resolvedTypeBinding, this);
+			}
+			// if no default case, then record it may jump over the block directly to the end
+			if (this.defaultCase == null && needToCheckFlowInAbsenceOfDefaultBranch()) {
+				// only retain the potential initializations
+				flowInfo.addPotentialInitializationsFrom(caseInits.mergedWith(switchContext.initsOnBreak));
+				this.mergedInitStateIndex = currentScope.methodScope().recordInitializationStates(flowInfo);
+				return flowInfo;
+			}
+
+			// merge all branches inits
+			FlowInfo mergedInfo = caseInits.mergedWith(switchContext.initsOnBreak);
+			this.mergedInitStateIndex =
+				currentScope.methodScope().recordInitializationStates(mergedInfo);
+			return mergedInfo;
+		} finally {
+			if (this.scope != null) this.scope.enclosingCase = null; // no longer inside switch case block
+		}
+	}
+
+	abstract static sealed class SwitchTranslator {
+
+		protected SwitchStatement swich;
+		int [] constants; // case constants or proxies;
+		int constantCount;
+		BranchLabel[] caseLabels;
+
+		public void setSwitch(SwitchStatement swich) {
+			this.swich = swich;
+		}
+
+		protected <T extends BranchLabel> void gatherLabels(CodeStream codeStream, Function<CodeStream, T> newLabel) {
+			for (int i = 0, j = 0, max = this.swich.caseCount; i < max; i++) {
+				CaseStatement stmt = this.swich.cases[i];
+				T label;
+				stmt.targetLabel = label = newLabel.apply(codeStream);
+				for (Expression e : stmt.peeledLabelExpressions()) {
+					if (e instanceof FakeDefaultLiteral) continue;
+					this.caseLabels[j++] = label;
+				}
+			}
+		}
+
+		protected void initializeLabels(CodeStream codeStream) {
+			this.swich.breakLabel.initialize(codeStream);
+			this.caseLabels = new CaseLabel[this.swich.nConstants];
+			gatherLabels(codeStream, CaseLabel::new);
+			this.swich.defaultLabel = this.swich.defaultCase != null ? (CaseLabel) this.swich.defaultCase.targetLabel :
+											this.swich.unconditionalPatternCase != null ? (CaseLabel) this.swich.unconditionalPatternCase.targetLabel : new CaseLabel(codeStream);
+		}
+
+		protected void gatherCaseConstantsOrProxies() {
+			this.constantCount = this.swich.labelExpressions.length;
+			this.constants = new int [this.constantCount];
+			for (int i = 0, length = this.swich.labelExpressions.length; i < length; ++i)
+				this.constants[i] = this.swich.labelExpressions[i].intValue();
+		}
+
+		protected void finalizeLabels(CodeStream codeStream) {
+			// nothing to do - initial labels are good enough to be final labels.
+		}
+
+		protected void generateSelectorExpression(BlockScope currentScope, CodeStream codeStream) {
+			this.swich.expression.generateCode(currentScope, codeStream, true);
+			if (this.swich.expression.resolvedType.id == TypeIds.T_JavaLangBoolean)
+				codeStream.generateUnboxingConversion(TypeIds.T_boolean); // optimize by avoiding indy typeSwitch
+		}
+
+		protected void generateSwitchByteCode(BlockScope currentScope, CodeStream codeStream) {
+			if ((this.swich.switchBits & HasNondefaultCase) != 0) { // generate the appropriate switch table/lookup bytecode
+				int[] sortedIndexes = new int[this.constantCount];
+				for (int i = 0; i < this.constantCount; i++)
+					sortedIndexes[i] = i;
+				int[] localKeysCopy;
+				System.arraycopy(this.constants, 0, (localKeysCopy = new int[this.constantCount]), 0, this.constantCount);
+				CodeStream.sort(localKeysCopy, 0, this.constantCount - 1, sortedIndexes);
+
+				int max = localKeysCopy[this.constantCount - 1];
+				int min = localKeysCopy[0];
+				if ((long) (this.constantCount * 2.5) > ((long) max - (long) min))
+					codeStream.tableswitch(this.swich.defaultLabel, min, max, this.constants, sortedIndexes, (CaseLabel[]) this.caseLabels);
+				else
+					codeStream.lookupswitch(this.swich.defaultLabel, this.constants, sortedIndexes, (CaseLabel[]) this.caseLabels);
+				codeStream.recordPositionsFrom(codeStream.position, this.swich.expression.sourceEnd);
+			} else {
+				codeStream.pop();
+			}
+		}
+
+		protected final void generateSwitchBlock (BlockScope currentScope, CodeStream codeStream) {
+			if (this.swich.statements != null) {
+				for (Statement statement : this.swich.statements) {
+					if (statement instanceof CaseStatement caseStatement) {
+						this.swich.scope.enclosingCase = caseStatement; // record entering in a switch case block
+						if (this.swich.preSwitchInitStateIndex != -1)
+							codeStream.removeNotDefinitelyAssignedVariables(currentScope, this.swich.preSwitchInitStateIndex);
+					}
+					statement.generateCode(this.swich.scope, codeStream);
+					if (statement instanceof Block block && (block.bits & BlockShouldEndDead) != 0)
+						codeStream.goto_(this.swich.breakLabel);
+				}
+			}
+		}
+
+		protected final void generateDefaultCase(BlockScope currentScope, CodeStream codeStream) {
+			if (this.swich.defaultCase == null && this.swich.unconditionalPatternCase == null) {
+				boolean needsThrowingDefault = false;
+				needsThrowingDefault = this.swich.expression.resolvedType.isEnum() && (this.swich instanceof SwitchExpression || this.swich.containsNull);
+				needsThrowingDefault |= this.swich.isExhaustive(); // pattern switches:
+				if (needsThrowingDefault) {
+					if (this.swich.preSwitchInitStateIndex != -1)
+						codeStream.removeNotDefinitelyAssignedVariables(currentScope, this.swich.preSwitchInitStateIndex);
+					if (this.swich.scope.compilerOptions().complianceLevel >= ClassFileConstants.JDK19) { // since 19 we have MatchException for this
+						if ((this.swich.switchBits & BarricadeInjectedDefault) != 0)
+							codeStream.goto_(this.swich.breakLabel); // hop, skip and jump over match exception throw.
+						this.swich.defaultLabel.place();
+						codeStream.newJavaLangMatchException();
+						codeStream.dup();
+						codeStream.aconst_null();
+						codeStream.aconst_null();
+						codeStream.invokeJavaLangMatchExceptionConstructor();
+						codeStream.athrow();
+					} else { // old style using IncompatibleClassChangeError:
+						this.swich.defaultLabel.place();
+						codeStream.newJavaLangIncompatibleClassChangeError();
+						codeStream.dup();
+						codeStream.invokeJavaLangIncompatibleClassChangeErrorDefaultConstructor();
+						codeStream.athrow();
+					}
+				}
+			}
+		}
+
+		protected final void generateEpilogue(BlockScope currentScope, CodeStream codeStream, int pc) {
+			this.swich.breakLabel.place();
+			if (this.swich.defaultLabel.position == Label.POS_NOT_SET) {
+				codeStream.recordPositionsFrom(codeStream.position, this.swich.sourceEnd, true); // force a line number entry to get an end position after the switch
+				this.swich.defaultLabel.place();
+			}
+			// May loose some local variable initializations : affecting the local variable attributes
+			if (this.swich.mergedInitStateIndex != -1) {
+				codeStream.removeNotDefinitelyAssignedVariables(currentScope, this.swich.mergedInitStateIndex);
+				codeStream.addDefinitelyAssignedVariables(currentScope, this.swich.mergedInitStateIndex);
+			}
+			codeStream.removeVariable(this.swich.selector);
+			if (this.swich.scope != currentScope)
+				codeStream.exitUserScope(this.swich.scope);
+			codeStream.recordPositionsFrom(pc, this.swich.sourceStart);
+		}
+
+		public final void generateCode(BlockScope currentScope, CodeStream codeStream) { // common main code generator driver for all switches - hence final
+
+			if ((this.swich.bits & IsReachable) == 0)
+				return;
+
+			try {
+				// Prepare labels & case constants or their proxies.
+				int pc = codeStream.position;
+				initializeLabels(codeStream); // assemble case labels, break label and default label
+				gatherCaseConstantsOrProxies();
+				finalizeLabels(codeStream); // actual cases may differ from what is seen in source code - e.g., String switch.
+				generateSelectorExpression(currentScope, codeStream);
+				generateSwitchByteCode(currentScope, codeStream);
+				generateSwitchBlock(currentScope, codeStream); // And also case label placement
+				generateDefaultCase(currentScope, codeStream); // inject a MatchException throw for binary incompatibility signaling
+				generateEpilogue(currentScope, codeStream, pc); // Epilogue: Place the trailing labels (for break and default case)
+			} finally {
+				if (this.swich.scope != null)
+					this.swich.scope.enclosingCase = null; // no longer inside switch case block
+			}
+		}
+
+		final static class ClassicSwitchTranslator extends SwitchTranslator {
+			// default behavior is fine enough.
+		}
+
+		final static class StringSwitchTranslator extends SwitchTranslator {
+
+			private record StringCaseConstant(int hashKode, String string, BranchLabel label) implements Comparable<StringCaseConstant> {
+				@Override
+				public int compareTo(StringCaseConstant that) {
+					return this.hashKode == that.hashKode ? 0 : this.hashKode > that.hashKode ? 1 : -1; // can't use just '-' due to potential overflow/underflow
+				}
+			}
+
+			private StringCaseConstant [] stringCaseConstants;
+
+			@Override
+			protected void initializeLabels(CodeStream codeStream) {
+				// prepare the labels and constants
+				this.swich.breakLabel.initialize(codeStream);
+				this.caseLabels = new BranchLabel[this.swich.nConstants];
+				gatherLabels(codeStream, BranchLabel::new);
+				this.swich.defaultLabel = new CaseLabel(codeStream, true /* allow narrow branch to */);
+				if (this.swich.defaultCase != null)
+					this.swich.defaultCase.targetLabel = this.swich.defaultLabel; // Replace the vanilla branch label with a case label that doubles as a branch label.
+
+			}
+
+			@Override
+			protected void gatherCaseConstantsOrProxies() { // proxies in this case - unique hash code values.
+				this.stringCaseConstants = new StringCaseConstant[this.swich.nConstants];
+
+				int [] hashCodes = new int[this.swich.nConstants];
+				for (int i = 0; i < this.swich.nConstants; i++) {
+					String literal = this.swich.labelExpressions[i].constant.stringValue();
+					this.stringCaseConstants[i] = new StringCaseConstant(literal.hashCode(), literal, this.caseLabels[i]);
+				}
+				Arrays.sort(this.stringCaseConstants);
+
+				int uniqHashCount = 0, lastHashCode = 0;
+				for (int i = 0; i < this.swich.nConstants; ++i) {
+					int hashCode = this.stringCaseConstants[i].hashKode;
+					if (i == 0 || hashCode != lastHashCode)
+						lastHashCode = hashCodes[uniqHashCount++] = hashCode;
+				}
+				if (uniqHashCount != this.swich.nConstants) // multiple keys hashed to the same value.
+					System.arraycopy(hashCodes, 0, hashCodes = new int[uniqHashCount], 0, uniqHashCount);
+				this.constants = hashCodes;
+				this.constantCount = uniqHashCount;
+			}
+
+			@Override
+			protected void finalizeLabels(CodeStream codeStream) {
+				this.caseLabels = new CaseLabel[this.constantCount];
+				for (int i = 0; i < this.constantCount; i++)
+					this.caseLabels[i] = new CaseLabel(codeStream);
+			}
+
+			@Override
+			protected void generateSelectorExpression(BlockScope currentScope, CodeStream codeStream) {
+				this.swich.expression.generateCode(currentScope, codeStream, true);
+				codeStream.store(this.swich.selector, true);  // leaves string on operand stack
+				codeStream.addVariable(this.swich.selector);
+				codeStream.invokeStringHashCode();
+			}
+
+			@Override
+			protected void generateSwitchByteCode(BlockScope currentScope, CodeStream codeStream) {
+				int[] sortedIndexes = new int[this.constantCount]; // hash code are sorted already anyways.
+				for (int i = 0; i < this.constantCount; i++)
+					sortedIndexes[i] = i;
+				int lastHashCode = 0;
+				codeStream.lookupswitch(this.swich.defaultLabel, this.constants, sortedIndexes, (CaseLabel[]) this.caseLabels);
+				for (int i = 0, j = 0; i < this.swich.nConstants; i++) {
+					int hashCode = this.stringCaseConstants[i].hashKode;
+					if (i == 0 || hashCode != lastHashCode) {
+						lastHashCode = hashCode;
+						if (i != 0)
+							codeStream.goto_(this.swich.defaultLabel);
+						this.caseLabels[j++].place();
+					}
+					codeStream.load(this.swich.selector);
+					codeStream.ldc(this.stringCaseConstants[i].string);
+					codeStream.invokeStringEquals();
+					codeStream.ifne(this.stringCaseConstants[i].label);
+				}
+				codeStream.goto_(this.swich.defaultLabel);
+			}
+		}
+
+		final static class EnumSwitchTranslator extends SwitchTranslator {
+
+			@Override
+			protected void generateSelectorExpression(BlockScope currentScope, CodeStream codeStream) {
+				// go through the translation table in order to guarantee binary compatibility promises of "13.4.26 Evolution of Enum Classes"
+				codeStream.invoke(Opcodes.OPC_invokestatic, this.swich.synthetic, null /* default declaringClass */);
+				this.swich.expression.generateCode(currentScope, codeStream, true);
+				codeStream.invokeEnumOrdinal(this.swich.expression.resolvedType.constantPoolName());
+				codeStream.iaload();
+			}
+		}
+
+		final static class PatternSwitchTranslator extends SwitchTranslator {
+
+			@Override
+			protected void gatherCaseConstantsOrProxies() {
+				this.constantCount = this.swich.labelExpressions.length;
+				this.constants = new int [this.constantCount];
+				for (int i = 0, j = 0, length = this.swich.labelExpressions.length; i < length; ++i) {
+					this.constants[i] = this.swich.labelExpressions[i].index - j;
+					if (this.swich.labelExpressions[i].expression instanceof NullLiteral)
+						j = 1;  // since we yank null out to -1, shift down everything beyond.
+				}
+			}
+
+			private char[] typeSwitchSignature(TypeBinding exprType) {
+				char[] arg1 = switch (exprType.id) {
+					case TypeIds.T_JavaLangLong, TypeIds.T_JavaLangFloat, TypeIds.T_JavaLangDouble, TypeIds.T_JavaLangBoolean,
+						TypeIds.T_JavaLangByte, TypeIds.T_JavaLangShort, TypeIds.T_JavaLangInteger, TypeIds.T_JavaLangCharacter->
+						this.swich.isPrimitiveSwitch
+						? exprType.signature()
+						: "Ljava/lang/Object;".toCharArray(); //$NON-NLS-1$
+					default -> {
+						if (exprType.id > TypeIds.T_LastWellKnownTypeId && exprType.erasure().isBoxedPrimitiveType())
+							yield exprType.erasure().signature(); // <T extends Integer> / <? extends Short> ...
+						else
+							yield exprType.isPrimitiveType()
+								? exprType.signature()
+								: "Ljava/lang/Object;".toCharArray(); //$NON-NLS-1$
+					}
+				};
+				return CharOperation.concat("(".toCharArray(), arg1, "I)I".toCharArray()); //$NON-NLS-1$ //$NON-NLS-2$
+			}
+
+			@Override
+			protected void generateSelectorExpression(BlockScope currentScope, CodeStream codeStream) {
+				this.swich.expression.generateCode(currentScope, codeStream, true);
+				if (!this.swich.containsNull && !this.swich.expression.resolvedType.isPrimitiveType()) {
+					codeStream.dup();
+					codeStream.invokeJavaUtilObjectsrequireNonNull();
+					codeStream.pop();
+				}
+
+				codeStream.store(this.swich.selector, false);
+				codeStream.addVariable(this.swich.selector);
+
+				int invokeDynamicNumber = codeStream.classFile.recordBootstrapMethod(this.swich);
+
+				codeStream.load(this.swich.selector);
+				codeStream.loadInt(0); // restartIndex
+				this.swich.switchPatternRestartTarget = new BranchLabel(codeStream);
+				this.swich.switchPatternRestartTarget.place();
+
+				if (this.swich.expression.resolvedType.isEnum()) {
+					String genericTypeSignature = new String(this.swich.expression.resolvedType.genericTypeSignature());
+					String callingParams = "(" + genericTypeSignature + "I)I"; //$NON-NLS-1$ //$NON-NLS-2$
+					codeStream.invokeDynamic(invokeDynamicNumber,
+							2, // Object, restartIndex
+							1, // int
+							"enumSwitch".toCharArray(), //$NON-NLS-1$
+							callingParams.toCharArray(),
+							TypeBinding.INT);
+				} else {
+					TypeBinding exprType = this.swich.expression.resolvedType;
+					char[] signature = typeSwitchSignature(exprType);
+					int argsSize = TypeIds.getCategory(exprType.id) + 1; // Object | PRIM, restartIndex (PRIM = Z|S|I..)
+					codeStream.invokeDynamic(invokeDynamicNumber,
+							argsSize,
+							1, // int
+							ConstantPool.TYPESWITCH,
+							signature,
+							TypeBinding.INT);
+				}
+
+				for (int i = 0; i < this.swich.labelExpressions.length; i++) {
+					LabelExpression c = this.swich.labelExpressions[i];
+					if (c.type.isPrimitiveType()) {
+						SingletonBootstrap descriptor = c.isPattern() ? PRIMITIVE_CLASS__BOOTSTRAP : c.type.id == TypeIds.T_boolean ? GET_STATIC_FINAL__BOOTSTRAP : null;
+						if (descriptor != null)
+							c.primitivesBootstrapIdx = codeStream.classFile.recordSingletonBootstrapMethod(descriptor);
+					} else if (c.isQualifiedEnum()) {
+						c.enumDescIdx = codeStream.classFile.recordBootstrapMethod(c);
+						c.classDescIdx = codeStream.classFile.recordBootstrapMethod(c.type);
+					}
+				}
+			}
+		}
+	}
+
+	@Override
+	public void generateCode(BlockScope currentScope, CodeStream codeStream) {
+		SwitchTranslator translator = needPatternDispatchCopy() ? new SwitchTranslator.PatternSwitchTranslator() :
+			this.expression.resolvedType.id == TypeIds.T_JavaLangString && !this.isNonTraditional ? new SwitchTranslator.StringSwitchTranslator() :
+					this.expression.resolvedType.isEnum() ? new SwitchTranslator.EnumSwitchTranslator() : new SwitchTranslator.ClassicSwitchTranslator();
+		translator.setSwitch(this);
+		translator.generateCode(currentScope, codeStream);
+	}
+
+	@Override
+	public boolean isTrulyExpression() {
+		return false;
+	}
+
 	@Override
 	public boolean doesNotCompleteNormally() {
 		if (this.statements == null || this.statements.length == 0)
@@ -1361,56 +1246,37 @@ public boolean completesByContinue() {
 	}
 
 	@Override
-	public boolean canCompleteNormally() {
-		if (this.statements == null || this.statements.length == 0)
-			return true;
-		if ((this.switchBits & LabeledRules) == 0) { // switch labeled statement group
-			if (this.statements[this.statements.length - 1].canCompleteNormally())
-				return true; // last statement as well as last switch label after blocks if exists.
-			if (this.totalPattern == null && this.defaultCase == null)
-				return true;
+	public StringBuilder printStatement(int indent, StringBuilder output) {
+		printIndent(indent, output).append("switch ("); //$NON-NLS-1$
+		this.expression.printExpression(0, output).append(") {"); //$NON-NLS-1$
+		if (this.statements != null) {
 			for (Statement statement : this.statements) {
-				if (statement.breaksOut(null))
-					return true;
-			}
-		} else {
-			// switch block consists of switch rules
-			for (Statement stmt : this.statements) {
-				if (stmt instanceof CaseStatement)
-					continue; // skip case
-				if (this.totalPattern == null && this.defaultCase == null)
-					return true;
-				if (stmt instanceof Expression)
-					return true;
-				if (stmt.canCompleteNormally())
-					return true;
-				if (stmt instanceof YieldStatement && ((YieldStatement) stmt).isImplicit) // note: artificially introduced
-					return true;
-				if (stmt instanceof Block) {
-					Block block = (Block) stmt;
-					if (block.canCompleteNormally())
-						return true;
-					if (block.breaksOut(null))
-						return true;
-				}
+				output.append('\n');
+				if (statement instanceof CaseStatement)
+					statement.printStatement(indent, output);
+				else
+					statement.printStatement(indent+2, output);
 			}
 		}
-		return false;
+		output.append("\n"); //$NON-NLS-1$
+		return printIndent(indent, output).append('}');
 	}
 
 	@Override
-	public boolean continueCompletes() {
-		if (this.statements == null || this.statements.length == 0)
-			return false;
-		for (Statement statement : this.statements) {
-			if (statement.continueCompletes())
-				return true;
-		}
-		return false;
+	public StringBuilder printExpression(int indent, StringBuilder output) {
+		return printStatement(indent, output);
 	}
 
 	@Override
-	public StringBuilder printExpression(int indent, StringBuilder output) {
-		return printStatement(indent, output);
+	public void traverse(ASTVisitor visitor, BlockScope blockScope) {
+		if (visitor.visit(this, blockScope)) {
+			this.expression.traverse(visitor, blockScope);
+			if (this.statements != null) {
+				int statementsLength = this.statements.length;
+				for (int i = 0; i < statementsLength; i++)
+					this.statements[i].traverse(visitor, this.scope);
+			}
+		}
+		visitor.endVisit(this, blockScope);
 	}
-}
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/SynchronizedStatement.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/SynchronizedStatement.java
index 24e5b024559..2ad5d2895eb 100644
--- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/SynchronizedStatement.java
+++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/SynchronizedStatement.java
@@ -248,14 +248,4 @@ public boolean doesNotCompleteNormally() {
 public boolean completesByContinue() {
 	return this.block.completesByContinue();
 }
-
-@Override
-public boolean canCompleteNormally() {
-	return this.block.canCompleteNormally();
-}
-
-@Override
-public boolean continueCompletes() {
-	return this.block.continueCompletes();
-}
 }
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/ThrowStatement.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/ThrowStatement.java
index bfa0da9ba7a..c510de8d41b 100644
--- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/ThrowStatement.java
+++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/ThrowStatement.java
@@ -99,10 +99,4 @@ public void traverse(ASTVisitor visitor, BlockScope blockScope) {
 public boolean doesNotCompleteNormally() {
 	return true;
 }
-
-@Override
-public boolean canCompleteNormally() {
-	return false;
-}
-
 }
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/TryStatement.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/TryStatement.java
index 228388b1a3a..632f903810b 100644
--- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/TryStatement.java
+++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/TryStatement.java
@@ -1270,34 +1270,4 @@ public boolean completesByContinue() {
 	}
 	return this.finallyBlock != null && this.finallyBlock.completesByContinue();
 }
-@Override
-public boolean canCompleteNormally() {
-	if (this.tryBlock.canCompleteNormally()) {
-		return (this.finallyBlock != null) ? this.finallyBlock.canCompleteNormally() : true;
-	}
-	if (this.catchBlocks != null) {
-		for (Block catchBlock : this.catchBlocks) {
-			if (catchBlock.canCompleteNormally()) {
-				return (this.finallyBlock != null) ? this.finallyBlock.canCompleteNormally() : true;
-			}
-		}
-	}
-	return false;
-}
-@Override
-public boolean continueCompletes() {
-	if (this.tryBlock.continueCompletes()) {
-		return (this.finallyBlock == null) ? true :
-			this.finallyBlock.canCompleteNormally() || this.finallyBlock.continueCompletes();
-	}
-	if (this.catchBlocks != null) {
-		for (Block catchBlock : this.catchBlocks) {
-			if (catchBlock.continueCompletes()) {
-				return (this.finallyBlock == null) ? true :
-					this.finallyBlock.canCompleteNormally() || this.finallyBlock.continueCompletes();
-			}
-		}
-	}
-	return this.finallyBlock != null && this.finallyBlock.continueCompletes();
-}
 }
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/WhileStatement.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/WhileStatement.java
index e0a895c7076..9154521f122 100644
--- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/WhileStatement.java
+++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/WhileStatement.java
@@ -242,7 +242,6 @@ public void generateCode(BlockScope currentScope, CodeStream codeStream) {
 		// generate the action
 		BranchLabel actionLabel = new BranchLabel(codeStream);
 		if (this.action != null) {
-			actionLabel.tagBits |= BranchLabel.USED;
 			// Required to fix 1PR0XVS: LFRE:WINNT - Compiler: variable table for method appears incorrect
 			if (this.condIfTrueInitStateIndex != -1) {
 				// insert all locals initialized inside the condition into the action generated prior to the condition
@@ -340,20 +339,4 @@ public boolean doesNotCompleteNormally() {
 	public boolean completesByContinue() {
 		return this.action.continuesAtOuterLabel();
 	}
-
-	@Override
-	public boolean canCompleteNormally() {
-		Constant cst = this.condition.constant;
-		boolean isConditionTrue = cst == null || cst != Constant.NotAConstant && cst.booleanValue() == true;
-		cst = this.condition.optimizedBooleanConstant();
-		boolean isConditionOptimizedTrue = cst == null ? true : cst != Constant.NotAConstant && cst.booleanValue() == true;
-		if (!(isConditionTrue || isConditionOptimizedTrue))
-			return true;
-		return this.action != null && this.action.breaksOut(null);
-	}
-
-	@Override
-	public boolean continueCompletes() {
-		return this.action.continuesAtOuterLabel();
-	}
 }
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/YieldStatement.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/YieldStatement.java
index 4508678c981..e5cc1bb233b 100644
--- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/YieldStatement.java
+++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/YieldStatement.java
@@ -187,9 +187,4 @@ public void traverse(ASTVisitor visitor, BlockScope blockscope) {
 public boolean doesNotCompleteNormally() {
 	return true;
 }
-
-@Override
-public boolean canCompleteNormally() {
-	return false;
-}
 }
\ No newline at end of file
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/batch/ClasspathDirectory.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/batch/ClasspathDirectory.java
index 18ae5d338a1..43dffd9c32a 100644
--- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/batch/ClasspathDirectory.java
+++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/batch/ClasspathDirectory.java
@@ -26,10 +26,10 @@
 import java.nio.file.SimpleFileVisitor;
 import java.nio.file.attribute.BasicFileAttributes;
 import java.util.HashSet;
-import java.util.Hashtable;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Function;
 import java.util.stream.Stream;
 import org.eclipse.jdt.core.compiler.CharOperation;
@@ -37,6 +37,7 @@
 import org.eclipse.jdt.internal.compiler.DefaultErrorHandlingPolicies;
 import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
 import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
+import org.eclipse.jdt.internal.compiler.batch.FileSystem.Classpath;
 import org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader;
 import org.eclipse.jdt.internal.compiler.classfmt.ClassFormatException;
 import org.eclipse.jdt.internal.compiler.classfmt.ExternalAnnotationProvider;
@@ -51,18 +52,17 @@
 import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;
 import org.eclipse.jdt.internal.compiler.util.Util;
 
-@SuppressWarnings({"rawtypes", "unchecked"})
 public class ClasspathDirectory extends ClasspathLocation {
 
-private Hashtable directoryCache;
-private final String[] missingPackageHolder = new String[1];
-private final int mode; // ability to only consider one kind of files (source vs. binaries), by default use both
-private final String encoding; // only useful if referenced in the source path
-private Hashtable<String, Hashtable<String, String>> packageSecondaryTypes = null;
-Map options;
+	private final Map<String, String[]> directoryCache = new ConcurrentHashMap<>();
+	private final String[] missingPackageHolder = new String[1];
+	private final int mode; // ability to only consider one kind of files (source vs. binaries), by default use both
+	private final String encoding; // only useful if referenced in the source path
+	private final Map<String, Map<String, String>> packageSecondaryTypes = new ConcurrentHashMap<>();
+	private final Map<String, String> options;
 
 ClasspathDirectory(File directory, String encoding, int mode,
-		AccessRuleSet accessRuleSet, String destinationPath, Map options) {
+		AccessRuleSet accessRuleSet, String destinationPath, Map<String, String> options) {
 	super(accessRuleSet, destinationPath);
 	this.mode = mode;
 	this.options = options;
@@ -74,43 +74,49 @@ public class ClasspathDirectory extends ClasspathLocation {
 	}
 	if (!this.path.endsWith(File.separator))
 		this.path += File.separator;
-	this.directoryCache = new Hashtable(11);
 	this.encoding = encoding;
 }
-String[] directoryList(String qualifiedPackageName) {
-	if (File.separatorChar != '/' && qualifiedPackageName.indexOf('/') != -1) {
-		qualifiedPackageName = qualifiedPackageName.replace('/', File.separatorChar);
-	}
-	String[] dirList = (String[]) this.directoryCache.get(qualifiedPackageName);
-	if (dirList == this.missingPackageHolder) return null; // package exists in another classpath directory or jar
-	if (dirList != null) return dirList;
 
-	File dir = new File(this.path + qualifiedPackageName);
-	notFound : if (dir.isDirectory()) {
-		// must protect against a case insensitive File call
-		// walk the qualifiedPackageName backwards looking for an uppercase character before the '/'
-		int index = qualifiedPackageName.length();
-		int last = qualifiedPackageName.lastIndexOf(File.separatorChar);
-		while (--index > last && !ScannerHelper.isUpperCase(qualifiedPackageName.charAt(index))){/*empty*/}
-		if (index > last) {
-			if (last == -1) {
-				if (!doesFileExist(qualifiedPackageName, Util.EMPTY_STRING))
-					break notFound;
-			} else {
-				String packageName = qualifiedPackageName.substring(last + 1);
-				String parentPackage = qualifiedPackageName.substring(0, last);
-				if (!doesFileExist(packageName, parentPackage))
-					break notFound;
-			}
+private String[] directoryList(String qualifiedPackageName) {
+	String qualifiedPackagePath = qualifiedPackageName.replace('/', File.separatorChar);
+	// must protect against a case insensitive File call
+	// walk the qualifiedPackageName backwards looking for an uppercase character before the '/'
+	int index = qualifiedPackagePath.length();
+	int last = qualifiedPackagePath.lastIndexOf(File.separatorChar);
+	while (--index > last && !ScannerHelper.isUpperCase(qualifiedPackagePath.charAt(index))) {
+		/* empty */}
+	if (index > last) {
+		if (last == -1) {
+			if (!doesFileExist(qualifiedPackagePath, Util.EMPTY_STRING))
+				return null;
+		} else {
+			String packageName = qualifiedPackagePath.substring(last + 1);
+			String parentPackage = qualifiedPackagePath.substring(0, last);
+			if (!doesFileExist(packageName, parentPackage))
+				return null;
 		}
-		if ((dirList = dir.list()) == null)
+	}
+
+	String[] cached = this.directoryCache.computeIfAbsent(qualifiedPackageName, this::computeDirectoryList);
+	if (cached == this.missingPackageHolder) {
+		return null; // package exists in another classpath directory or jar
+	}
+	return cached;
+}
+
+private String[] computeDirectoryList(String qualifiedPackageName) {
+	String qualifiedPackagePath = qualifiedPackageName.replace('/', File.separatorChar);
+	File dir = new File(this.path + qualifiedPackagePath);
+	String[] dirList = dir.list();
+	if (dirList != null) { // if isDirectory
+		if (dirList.length == 0) {
 			dirList = CharOperation.NO_STRINGS;
-		this.directoryCache.put(qualifiedPackageName, dirList);
+		}
 		return dirList;
 	}
-	this.directoryCache.put(qualifiedPackageName, this.missingPackageHolder);
-	return null;
+	return this.missingPackageHolder;
 }
+
 boolean doesFileExist(String fileName, String qualifiedPackageName) {
 	String[] dirList = directoryList(qualifiedPackageName);
 	if (dirList == null) return false; // most common case
@@ -121,7 +127,7 @@ boolean doesFileExist(String fileName, String qualifiedPackageName) {
 	return false;
 }
 @Override
-public List fetchLinkedJars(FileSystem.ClasspathSectionProblemReporter problemReporter) {
+public List<Classpath> fetchLinkedJars(FileSystem.ClasspathSectionProblemReporter problemReporter) {
 	return null;
 }
 private NameEnvironmentAnswer findClassInternal(char[] typeName, String qualifiedPackageName, String qualifiedBinaryFileName, boolean asBinaryOnly) {
@@ -202,10 +208,10 @@ public NameEnvironmentAnswer findClass(char[] typeName, String qualifiedPackageN
 /**
  *  Add all the secondary types in the package
  */
-private Hashtable<String, String> getSecondaryTypes(String qualifiedPackageName) {
-	Hashtable<String, String> packageEntry = new Hashtable<>();
+private Map<String, String> getSecondaryTypes(String qualifiedPackageName) {
+	Map<String, String> packageEntry = new ConcurrentHashMap<>();
 
-	String[] dirList = (String[]) this.directoryCache.get(qualifiedPackageName);
+	String[] dirList = this.directoryCache.get(qualifiedPackageName);
 	if (dirList == this.missingPackageHolder // package exists in another classpath directory or jar
 			|| dirList == null)
 		return packageEntry;
@@ -241,13 +247,7 @@ private Hashtable<String, String> getSecondaryTypes(String qualifiedPackageName)
 	return packageEntry;
 }
 private NameEnvironmentAnswer findSourceSecondaryType(String typeName, String qualifiedPackageName, String qualifiedBinaryFileName) {
-
-	if (this.packageSecondaryTypes == null) this.packageSecondaryTypes = new Hashtable<>();
-	Hashtable<String, String> packageEntry = this.packageSecondaryTypes.get(qualifiedPackageName);
-	if (packageEntry == null) {
-		packageEntry = 	getSecondaryTypes(qualifiedPackageName);
-		this.packageSecondaryTypes.put(qualifiedPackageName, packageEntry);
-	}
+	Map<String, String> packageEntry = this.packageSecondaryTypes.computeIfAbsent(qualifiedPackageName, this::getSecondaryTypes);
 	String fileName = packageEntry.get(typeName);
 	return fileName != null ? new NameEnvironmentAnswer(new CompilationUnit(null,
 			fileName, this.encoding, this.destinationPath),
@@ -360,7 +360,8 @@ public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
 @Override
 public void reset() {
 	super.reset();
-	this.directoryCache = new Hashtable(11);
+	this.directoryCache.clear();
+	this.packageSecondaryTypes.clear();
 }
 @Override
 public String toString() {
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/batch/Main.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/batch/Main.java
index 109246b3997..ee07a3b172f 100644
--- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/batch/Main.java
+++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/batch/Main.java
@@ -1787,7 +1787,7 @@ public void configure(String[] argv) {
 
 	boolean didSpecifyDeprecation = false;
 	boolean didSpecifyCompliance = false;
-	boolean didSpecifyDisabledAnnotationProcessing = false;
+	boolean disableAnnotationProcessing = false;
 
 	String customEncoding = null;
 	String customDestinationPath = null;
@@ -2475,6 +2475,7 @@ public void configure(String[] argv) {
 					continue;
 				}
 				if (currentArg.equals("-proc:only")) { //$NON-NLS-1$
+					disableAnnotationProcessing = false;
 					this.options.put(
 						CompilerOptions.OPTION_GenerateClassFiles,
 						CompilerOptions.DISABLED);
@@ -2482,13 +2483,22 @@ public void configure(String[] argv) {
 					continue;
 				}
 				if (currentArg.equals("-proc:none")) { //$NON-NLS-1$
-					didSpecifyDisabledAnnotationProcessing = true;
+					disableAnnotationProcessing = true;
 					this.options.put(
 						CompilerOptions.OPTION_Process_Annotations,
 						CompilerOptions.DISABLED);
 					mode = DEFAULT;
 					continue;
 				}
+				if (currentArg.equals("-proc:full")) { //$NON-NLS-1$
+					// Enable, just in case we had a -proc:only before this that disabled this
+					this.options.put(
+							CompilerOptions.OPTION_GenerateClassFiles,
+							CompilerOptions.ENABLED);
+					disableAnnotationProcessing = false;
+					mode = DEFAULT;
+					continue;
+				}
 				if (currentArg.equals("-s")) { //$NON-NLS-1$
 					mode = INSIDE_S_start;
 					continue;
@@ -2946,8 +2956,7 @@ public void configure(String[] argv) {
 
 	// Enable annotation processing by default in batch mode when compliance is at least 1.6
 	// see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=185768
-	if (!didSpecifyDisabledAnnotationProcessing
-			&& CompilerOptions.versionToJdkLevel(this.options.get(CompilerOptions.OPTION_Compliance)) >= ClassFileConstants.JDK1_6) {
+	if (!disableAnnotationProcessing) {
 		this.options.put(CompilerOptions.OPTION_Process_Annotations, CompilerOptions.ENABLED);
 	}
 
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/codegen/BranchLabel.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/codegen/BranchLabel.java
index 2843f99581b..0360a8032f6 100644
--- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/codegen/BranchLabel.java
+++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/codegen/BranchLabel.java
@@ -30,8 +30,7 @@ public class BranchLabel extends Label {
 	public int tagBits;
 	protected int targetStackDepth = -1;
 	public final static int WIDE = 1;
-	public final static int USED = 2;
-	public final static int VALIDATE = 4;
+	public final static int VALIDATE = 2;
 	private OperandStack operandStack;
 
 
@@ -194,7 +193,6 @@ protected void trackStackDepth(boolean branch) {
 * Put down  a reference to the array at the location in the codestream.
 */
 void branch() {
-	this.tagBits |= BranchLabel.USED;
 	if (this.delegate != null) {
 		this.delegate.branch();
 		return;
@@ -213,11 +211,7 @@ void branch() {
 	trackStackDepth(true);
 }
 
-/*
-* No support for wide branches yet
-*/
 void branchWide() {
-	this.tagBits |= BranchLabel.USED;
 	if (this.delegate != null) {
 		this.delegate.branchWide();
 		return;
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/codegen/CaseLabel.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/codegen/CaseLabel.java
index dd898a7de29..0ee5938af58 100644
--- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/codegen/CaseLabel.java
+++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/codegen/CaseLabel.java
@@ -16,21 +16,29 @@
 public class CaseLabel extends BranchLabel {
 
 	public int instructionPosition = POS_NOT_SET;
+	private BranchLabel branchLabel; // doppelganger
 
-/**
- * CaseLabel constructor comment.
- * @param codeStream org.eclipse.jdt.internal.compiler.codegen.CodeStream
- */
 public CaseLabel(CodeStream codeStream) {
 	super(codeStream);
 }
 
+public CaseLabel(CodeStream codeStream, boolean allowNarrowBranch) {
+	super(codeStream);
+	if (allowNarrowBranch)
+		this.branchLabel = new BranchLabel(codeStream);
+}
+
+@Override
+void branch() {
+	this.branchLabel.branch();
+}
+
 /*
 * Put down  a reference to the array at the location in the codestream.
 * #placeInstruction() must be performed prior to any #branch()
 */
 @Override
-void branch() {
+void branchWide() {
 	if (this.position == POS_NOT_SET) {
 		addForwardReference(this.codeStream.position);
 		// Leave 4 bytes free to generate the jump offset afterwards
@@ -45,14 +53,6 @@ void branch() {
 	trackStackDepth(true);
 }
 
-/*
-* No support for wide branches yet
-*/
-@Override
-void branchWide() {
-	branch(); // case label branch is already wide
-}
-
 @Override
 public boolean isCaseLabel() {
 	return true;
@@ -66,11 +66,7 @@ public boolean isStandardLabel(){
 */
 @Override
 public void place() {
-	if ((this.tagBits & USED) != 0) {
-		this.position = this.codeStream.getPosition();
-	} else {
-		this.position = this.codeStream.position;
-	}
+	this.position = this.codeStream.position;
 	if (this.instructionPosition != POS_NOT_SET) {
 		int offset = this.position - this.instructionPosition;
 		int[] forwardRefs = forwardReferences();
@@ -81,6 +77,8 @@ public void place() {
 		this.codeStream.addLabel(this);
 	}
 	trackStackDepth(false);
+	if (this.branchLabel != null)
+		this.branchLabel.place();
 }
 
 /*
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/codegen/CodeStream.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/codegen/CodeStream.java
index 30b3436a218..dcad3e52df3 100644
--- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/codegen/CodeStream.java
+++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/codegen/CodeStream.java
@@ -3690,9 +3690,6 @@ public static TypeBinding getConstantPoolDeclaringClass(Scope currentScope, Meth
 	}
 	return constantPoolDeclaringClass;
 }
-protected int getPosition() {
-	return this.position;
-}
 
 public void getClass(TypeBinding baseType) {
 	this.countLabels = 0;
@@ -6351,11 +6348,11 @@ public void lookupswitch(CaseLabel defaultLabel, int[] keys, int[] sortedIndexes
 		this.position++;
 		this.bCodeStream[this.classFileOffset++] = 0;
 	}
-	defaultLabel.branch();
+	defaultLabel.branchWide();
 	writeSignedWord(length);
 	for (int i = 0; i < length; i++) {
 		writeSignedWord(keys[sortedIndexes[i]]);
-		casesLabel[sortedIndexes[i]].branch();
+		casesLabel[sortedIndexes[i]].branchWide();
 	}
 	this.lastAbruptCompletion = this.position; // multiway goto, with no fall through
 }
@@ -7522,7 +7519,7 @@ public void tableswitch(CaseLabel defaultLabel, int low, int high, int[] keys, i
 		this.position++;
 		this.bCodeStream[this.classFileOffset++] = 0;
 	}
-	defaultLabel.branch();
+	defaultLabel.branchWide();
 	writeSignedWord(low);
 	writeSignedWord(high);
 	int i = low, j = 0;
@@ -7533,11 +7530,11 @@ public void tableswitch(CaseLabel defaultLabel, int low, int high, int[] keys, i
 		int index = sortedIndexes[j];
 		int key = keys[index];
 		if (key == i) {
-			casesLabel[index].branch();
+			casesLabel[index].branchWide();
 			j++;
 			if (i == high) break; // if high is maxint, then avoids wrapping to minint.
 		} else {
-			defaultLabel.branch();
+			defaultLabel.branchWide();
 		}
 		i++;
 	}
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/codegen/ExceptionLabel.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/codegen/ExceptionLabel.java
index a5544806af1..3c6553658cc 100644
--- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/codegen/ExceptionLabel.java
+++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/codegen/ExceptionLabel.java
@@ -46,7 +46,7 @@ public int getCount() {
 public void place() {
 	// register the handler inside the codeStream then normal place
 	this.codeStream.registerExceptionHandler(this);
-	this.position = this.codeStream.getPosition();
+	this.position = this.codeStream.position;
 	this.codeStream.stackDepth = 1;
 }
 
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/codegen/ObjectCache.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/codegen/ObjectCache.java
deleted file mode 100644
index 42fef985aa3..00000000000
--- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/codegen/ObjectCache.java
+++ /dev/null
@@ -1,162 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2000, 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.compiler.codegen;
-
-public class ObjectCache {
-	public Object keyTable[];
-	public int valueTable[];
-	int elementSize;
-	int threshold;
-/**
- * Constructs a new, empty hashtable. A default capacity is used.
- * Note that the hashtable will automatically grow when it gets full.
- */
-public ObjectCache() {
-	this(13);
-}
-/**
- * Constructs a new, empty hashtable with the specified initial
- * capacity.
- * @param initialCapacity int
- *  the initial number of buckets
- */
-public ObjectCache(int initialCapacity) {
-	this.elementSize = 0;
-	this.threshold = (int) (initialCapacity * 0.66f);
-	this.keyTable = new Object[initialCapacity];
-	this.valueTable = new int[initialCapacity];
-}
-/**
- * Clears the hash table so that it has no more elements in it.
- */
-public void clear() {
-	for (int i = this.keyTable.length; --i >= 0;) {
-		this.keyTable[i] = null;
-		this.valueTable[i] = 0;
-	}
-	this.elementSize = 0;
-}
-/** Returns true if the collection contains an element for the key.
- *
- * @param key char[] the key that we are looking for
- * @return boolean
- */
-public boolean containsKey(Object key) {
-	int index = hashCode(key), length = this.keyTable.length;
-	while (this.keyTable[index] != null) {
-		if (this.keyTable[index] == key)
-			return true;
-		if (++index == length) {
-			index = 0;
-		}
-	}
-	return false;
-}
-/** Gets the object associated with the specified key in the
- * hashtable.
- * @param key <CODE>char[]</CODE> the specified key
- * @return int the element for the key or -1 if the key is not
- *  defined in the hash table.
- */
-public int get(Object key) {
-	int index = hashCode(key), length = this.keyTable.length;
-	while (this.keyTable[index] != null) {
-		if (this.keyTable[index] == key)
-			return this.valueTable[index];
-		if (++index == length) {
-			index = 0;
-		}
-	}
-	return -1;
-}
-/**
- * Return the hashcode for the key parameter
- *
- * @param key org.eclipse.jdt.internal.compiler.lookup.MethodBinding
- * @return int
- */
-public int hashCode(Object key) {
-	return (key.hashCode() & 0x7FFFFFFF) % this.keyTable.length;
-}
-/**
- * Puts the specified element into the hashtable, using the specified
- * key.  The element may be retrieved by doing a get() with the same key.
- * The key and the element cannot be null.
- *
- * @param key <CODE>Object</CODE> the specified key in the hashtable
- * @param value <CODE>int</CODE> the specified element
- * @return int the old value of the key, or -1 if it did not have one.
- */
-public int put(Object key, int value) {
-	int index = hashCode(key), length = this.keyTable.length;
-	while (this.keyTable[index] != null) {
-		if (this.keyTable[index] == key)
-			return this.valueTable[index] = value;
-		if (++index == length) {
-			index = 0;
-		}
-	}
-	this.keyTable[index] = key;
-	this.valueTable[index] = value;
-
-	// assumes the threshold is never equal to the size of the table
-	if (++this.elementSize > this.threshold)
-		rehash();
-	return value;
-}
-/**
- * Rehashes the content of the table into a bigger table.
- * This method is called automatically when the hashtable's
- * size exceeds the threshold.
- */
-private void rehash() {
-	ObjectCache newHashtable = new ObjectCache(this.keyTable.length * 2);
-	for (int i = this.keyTable.length; --i >= 0;)
-		if (this.keyTable[i] != null)
-			newHashtable.put(this.keyTable[i], this.valueTable[i]);
-
-	this.keyTable = newHashtable.keyTable;
-	this.valueTable = newHashtable.valueTable;
-	this.threshold = newHashtable.threshold;
-}
-/**
- * Returns the number of elements contained in the hashtable.
- *
- * @return <CODE>int</CODE> The size of the table
- */
-public int size() {
-	return this.elementSize;
-}
-/**
- * Converts to a rather lengthy String.
- *
- * @return String the ascii representation of the receiver
- */
-@Override
-public String toString() {
-	int max = size();
-	StringBuilder buf = new StringBuilder();
-	buf.append("{"); //$NON-NLS-1$
-	for (int i = 0; i < max; ++i) {
-		if (this.keyTable[i] != null) {
-			buf.append(this.keyTable[i]).append("->").append(this.valueTable[i]); //$NON-NLS-1$
-		}
-		if (i < max) {
-			buf.append(", "); //$NON-NLS-1$
-		}
-	}
-	buf.append("}"); //$NON-NLS-1$
-	return buf.toString();
-}
-}
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/flow/ExceptionHandlingFlowContext.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/flow/ExceptionHandlingFlowContext.java
index 8eeccfb7ff2..5d8834aeed0 100644
--- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/flow/ExceptionHandlingFlowContext.java
+++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/flow/ExceptionHandlingFlowContext.java
@@ -20,6 +20,7 @@
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.IdentityHashMap;
 import java.util.List;
 import org.eclipse.jdt.internal.compiler.ast.ASTNode;
 import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
@@ -28,7 +29,6 @@
 import org.eclipse.jdt.internal.compiler.ast.TryStatement;
 import org.eclipse.jdt.internal.compiler.ast.TypeReference;
 import org.eclipse.jdt.internal.compiler.ast.UnionTypeReference;
-import org.eclipse.jdt.internal.compiler.codegen.ObjectCache;
 import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
 import org.eclipse.jdt.internal.compiler.lookup.CatchParameterBinding;
 import org.eclipse.jdt.internal.compiler.lookup.ExtraCompilerModifiers;
@@ -42,7 +42,6 @@
  * Reflects the context of code analysis, keeping track of enclosing
  *	try statements, exception handlers, etc...
  */
-@SuppressWarnings({"rawtypes", "unchecked"})
 public class ExceptionHandlingFlowContext extends FlowContext {
 
 	public final static int BitCacheSize = 32; // 32 bits per int
@@ -52,14 +51,14 @@ public class ExceptionHandlingFlowContext extends FlowContext {
 	int[] isNeeded;
 	// WARNING: This is an array that maps to catch blocks, not caught exceptions (which could be more than catch blocks in a multi-catch block)
 	UnconditionalFlowInfo[] initsOnExceptions;
-	ObjectCache indexes = new ObjectCache();
+	IdentityHashMap<ReferenceBinding, Integer> indexes = new IdentityHashMap<>();
 	boolean isMethodContext;
 
 	public UnconditionalFlowInfo initsOnReturn;
 	public FlowContext initializationParent; // special parent relationship only for initialization purpose
 
 	// for dealing with anonymous constructor thrown exceptions
-	public List extendedExceptions;
+	public List<TypeBinding> extendedExceptions;
 
 	private static final Argument[] NO_ARGUMENTS = new Argument[0];
 	public  Argument [] catchArguments;
@@ -255,7 +254,7 @@ public void mergeUnhandledException(TypeBinding newException){
 	boolean isRedundant = false;
 
 	for(int i = this.extendedExceptions.size()-1; i >= 0; i--){
-		switch(Scope.compareTypes(newException, (TypeBinding)this.extendedExceptions.get(i))){
+		switch(Scope.compareTypes(newException, this.extendedExceptions.get(i))){
 			case Scope.MORE_GENERIC :
 				this.extendedExceptions.remove(i);
 				break;
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/BoundSet.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/BoundSet.java
index 360a4ea4408..705866ac7a1 100644
--- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/BoundSet.java
+++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/BoundSet.java
@@ -1264,33 +1264,38 @@ private boolean superOnlyRaw(TypeBinding g, TypeBinding s, LookupEnvironment env
 	}
 
 	protected List<Pair<TypeBinding>> allSuperPairsWithCommonGenericType(TypeBinding s, TypeBinding t) {
-		return allSuperPairsWithCommonGenericTypeRecursive(s, t, new HashSet<>());
+		ArrayList<Pair<TypeBinding>> result = new ArrayList<>();
+		allSuperPairsWithCommonGenericTypeRecursive(s, t, result, new HashSet<>());
+		return result;
 	}
 
-	private List<Pair<TypeBinding>> allSuperPairsWithCommonGenericTypeRecursive(TypeBinding s, TypeBinding t, HashSet<TypeBinding> visited) {
+	private void allSuperPairsWithCommonGenericTypeRecursive(TypeBinding s, TypeBinding t, List<Pair<TypeBinding>> result, HashSet<Integer> visited) {
 		if (s == null || s.id == TypeIds.T_JavaLangObject || t == null || t.id == TypeIds.T_JavaLangObject)
-			return Collections.emptyList();
-		if (!visited.add(s.prototype()))
-			return Collections.emptyList();
-		List<Pair<TypeBinding>> result = new ArrayList<>();
-		if (s.isParameterizedType() && t.isParameterizedType() // optimization #1: clients of this method only want to compare type arguments
-				&& TypeBinding.equalsEquals(s.original(), t.original())) {
-			result.add(new Pair<>(s, t));
-		}
+			return;
+		if (!visited.add(s.id))
+			return;
+
+		// optimization: nothing interesting above equal types
 		if (TypeBinding.equalsEquals(s,  t))
-			return result; // optimization #2: nothing interesting above equal types
-		TypeBinding tSuper = t.findSuperTypeOriginatingFrom(s);
-		if (tSuper != null && s.isParameterizedType() && tSuper.isParameterizedType()) { // optimization #1 again
-			result.add(new Pair<>(s, tSuper));
+			return;
+
+		if (s.isParameterizedType()) { // optimization here and below: clients of this method only want to compare type arguments
+			if (TypeBinding.equalsEquals(s.original(), t.original())) {
+				if (t.isParameterizedType())
+					result.add(new Pair<>(s, t));
+			} else {
+				TypeBinding tSuper = t.findSuperTypeOriginatingFrom(s);
+				if (tSuper != null && tSuper.isParameterizedType())
+					result.add(new Pair<>(s, tSuper));
+			}
 		}
-		result.addAll(allSuperPairsWithCommonGenericTypeRecursive(s.superclass(), t, visited));
+		allSuperPairsWithCommonGenericTypeRecursive(s.superclass(), t, result, visited);
 		ReferenceBinding[] superInterfaces = s.superInterfaces();
 		if (superInterfaces != null) {
 			for (ReferenceBinding superInterface : superInterfaces) {
-				result.addAll(allSuperPairsWithCommonGenericTypeRecursive(superInterface, t, visited));
+				allSuperPairsWithCommonGenericTypeRecursive(superInterface, t, result, visited);
 			}
 		}
-		return result;
 	}
 
 	public TypeBinding getEquivalentOuterVariable(InferenceVariable variable, InferenceVariable[] outerVariables) {
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/ConstraintExceptionFormula.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/ConstraintExceptionFormula.java
index 04e33d08660..7e38870175f 100644
--- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/ConstraintExceptionFormula.java
+++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/ConstraintExceptionFormula.java
@@ -91,8 +91,7 @@ public Object reduce(InferenceContext18 inferenceContext) {
 			LambdaExpression lambda = ((LambdaExpression) this.left).resolveExpressionExpecting(this.right, inferenceContext.scope, inferenceContext);
 			if (lambda == null)
 				return TRUE; // cannot make use of this buggy constraint
-			Set<TypeBinding> ePrimeSet = lambda.getThrownExceptions();
-			ePrime = ePrimeSet.toArray(new TypeBinding[ePrimeSet.size()]);
+			ePrime = lambda.getThrownExceptions().toArray(TypeBinding[]::new);
 		} else {
 			ReferenceExpression referenceExpression = ((ReferenceExpression) this.left).resolveExpressionExpecting(this.right, scope, inferenceContext);
 			MethodBinding method = referenceExpression != null ? referenceExpression.binding : null;
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/MethodVerifier.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/MethodVerifier.java
index ca6c3dee197..27a1a46585c 100644
--- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/MethodVerifier.java
+++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/MethodVerifier.java
@@ -27,6 +27,7 @@
 
 import java.util.ArrayList;
 import java.util.HashSet;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Set;
 import org.eclipse.jdt.internal.compiler.ast.MethodDeclaration;
@@ -321,12 +322,12 @@ void checkForRedundantSuperinterfaces(ReferenceBinding superclass, ReferenceBind
 	}
 
 	ReferenceBinding[] itsInterfaces = null;
-	SimpleSet inheritedInterfaces = new SimpleSet(5);
+	Set<ReferenceBinding> inheritedInterfaces = new LinkedHashSet<>();
 	ReferenceBinding superType = superclass;
 	while (superType != null && superType.isValidBinding()) {
 		if ((itsInterfaces = superType.superInterfaces()) != Binding.NO_SUPERINTERFACES) {
 			for (ReferenceBinding inheritedInterface : itsInterfaces) {
-				if (!inheritedInterfaces.includes(inheritedInterface) && inheritedInterface.isValidBinding()) {
+				if (!inheritedInterfaces.contains(inheritedInterface) && inheritedInterface.isValidBinding()) {
 					if (interfacesToCheck.includes(inheritedInterface)) {
 						if (redundantInterfaces == null) {
 							redundantInterfaces = new SimpleSet(3);
@@ -350,10 +351,9 @@ void checkForRedundantSuperinterfaces(ReferenceBinding superclass, ReferenceBind
 		superType = superType.superclass();
 	}
 
-	int nextPosition = inheritedInterfaces.elementSize;
+	int nextPosition = inheritedInterfaces.size();
 	if (nextPosition == 0) return;
-	ReferenceBinding[] interfacesToVisit = new ReferenceBinding[nextPosition];
-	inheritedInterfaces.asArray(interfacesToVisit);
+	ReferenceBinding[] interfacesToVisit = inheritedInterfaces.toArray(ReferenceBinding[]::new);
 	for (int i = 0; i < nextPosition; i++) {
 		superType = interfacesToVisit[i];
 		if ((itsInterfaces = superType.superInterfaces()) != Binding.NO_SUPERINTERFACES) {
@@ -362,7 +362,7 @@ void checkForRedundantSuperinterfaces(ReferenceBinding superclass, ReferenceBind
 				System.arraycopy(interfacesToVisit, 0, interfacesToVisit = new ReferenceBinding[nextPosition + itsLength + 5], 0, nextPosition);
 			for (int a = 0; a < itsLength; a++) {
 				ReferenceBinding inheritedInterface = itsInterfaces[a];
-				if (!inheritedInterfaces.includes(inheritedInterface) && inheritedInterface.isValidBinding()) {
+				if (!inheritedInterfaces.contains(inheritedInterface) && inheritedInterface.isValidBinding()) {
 					if (interfacesToCheck.includes(inheritedInterface)) {
 						if (redundantInterfaces == null) {
 							redundantInterfaces = new SimpleSet(3);
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/parser/Parser.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/parser/Parser.java
index f2a4d85db6d..a412a0433cb 100644
--- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/parser/Parser.java
+++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/parser/Parser.java
@@ -9443,7 +9443,7 @@ protected void consumeSwitchRule(SwitchRuleKind kind) {
 		this.astStack[this.astPtr] = yieldStatement;
 	} else if (kind == SwitchRuleKind.BLOCK) {
 		Block block = (Block) this.astStack[this.astPtr];
-		block.bits |= ASTNode.SwitchRuleBlock;
+		block.bits |= ASTNode.BlockShouldEndDead;
 	}
 	concatNodeLists();
 }
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/problem/ProblemReporter.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/problem/ProblemReporter.java
index d44a5e6dcb5..50a50eb0cd9 100644
--- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/problem/ProblemReporter.java
+++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/problem/ProblemReporter.java
@@ -589,9 +589,9 @@ public static int getIrritant(int problemID) {
 
 		case IProblem.UnclosedCloseable:
 		case IProblem.UnclosedCloseableAtExit:
+			return CompilerOptions.UnclosedCloseable;
 		case IProblem.MandatoryCloseNotShown:
 		case IProblem.MandatoryCloseNotShownAtExit:
-			return CompilerOptions.UnclosedCloseable;
 		case IProblem.PotentiallyUnclosedCloseable:
 		case IProblem.PotentiallyUnclosedCloseableAtExit:
 			return CompilerOptions.PotentiallyUnclosedCloseable;
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/problem/messages.properties b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/problem/messages.properties
index f928348c096..93e3c443f13 100644
--- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/problem/messages.properties
+++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/problem/messages.properties
@@ -1035,7 +1035,7 @@
 1700 = Incompatible results expressions in switch
 ###[obsolete] 1701 = A switch expression should have a non-empty switch block
 1702 = A switch expression should have at least one result expression
-1703 = A switch labeled block in a switch expression should not complete normally
+1703 = A switch labeled block in a switch expression must yield a value or throw an an exception
 ###[obsolete] 1704 = The last statement of a switch block in a switch expression should not complete normally
 ###[obsolete] 1705 = Trailing switch labels are not allowed in a switch expression.
 1706 = Mixing of '->' and ':' case statement styles is not allowed within a switch
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/util/Util.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/util/Util.java
index de0395b8e8e..ea512ac345a 100644
--- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/util/Util.java
+++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/util/Util.java
@@ -14,9 +14,7 @@
  *******************************************************************************/
 package org.eclipse.jdt.internal.compiler.util;
 
-import java.io.BufferedOutputStream;
 import java.io.File;
-import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.PrintWriter;
@@ -231,7 +229,6 @@ public interface Displayable {
 		String displayString(Object o);
 	}
 
-	private static final int DEFAULT_WRITING_SIZE = 1024;
 	public final static String UTF_8 = "UTF-8";	//$NON-NLS-1$
 	public static final String LINE_SEPARATOR = System.getProperty("line.separator"); //$NON-NLS-1$
 
@@ -397,9 +394,9 @@ public static byte[] getFileByteContent(File file) throws IOException {
 	public static char[] getFileCharContent(File file, String encoding) throws IOException {
 		return org.eclipse.jdt.internal.compiler.util.Util.getBytesAsCharArray(Files.readAllBytes(file.toPath()), encoding);
 	}
-	private static FileOutputStream getFileOutputStream(boolean generatePackagesStructure, String outputPath, String relativeFileName) throws IOException {
+	private static File getFile(boolean generatePackagesStructure, String outputPath, String relativeFileName) throws IOException {
 		if (generatePackagesStructure) {
-			return new FileOutputStream(new File(buildAllDirectoriesInto(outputPath, relativeFileName)));
+			return new File(buildAllDirectoriesInto(outputPath, relativeFileName));
 		} else {
 			String fileName = null;
 			char fileSeparatorChar = File.separatorChar;
@@ -422,7 +419,7 @@ private static FileOutputStream getFileOutputStream(boolean generatePackagesStru
 					fileName = outputPath + fileSeparator + relativeFileName.substring(indexOfPackageSeparator + 1, length);
 				}
 			}
-			return new FileOutputStream(new File(fileName));
+			return new File(fileName);
 		}
 	}
 
@@ -915,34 +912,14 @@ public static String toString(Object[] objects, Displayable renderer) {
 	 * @param relativeFileName the given relative file name
 	 * @param classFile the given classFile to write
 	 */
-	public static void writeToDisk(boolean generatePackagesStructure, String outputPath, String relativeFileName, ClassFile classFile) throws IOException {
-		FileOutputStream file = getFileOutputStream(generatePackagesStructure, outputPath, relativeFileName);
-		/* use java.nio to write
-		if (true) {
-			FileChannel ch = file.getChannel();
-			try {
-				ByteBuffer buffer = ByteBuffer.allocate(classFile.headerOffset + classFile.contentsOffset);
-				buffer.put(classFile.header, 0, classFile.headerOffset);
-				buffer.put(classFile.contents, 0, classFile.contentsOffset);
-				buffer.flip();
-				while (true) {
-					if (ch.write(buffer) == 0) break;
-				}
-			} finally {
-				ch.close();
-			}
-			return;
-		}
-		*/
-		try (BufferedOutputStream output = new BufferedOutputStream(file, DEFAULT_WRITING_SIZE)) {
-			// if no IOException occured, output cannot be null
-			output.write(classFile.header, 0, classFile.headerOffset);
-			output.write(classFile.contents, 0, classFile.contentsOffset);
-			output.flush();
-		} catch(IOException e) {
-			throw e;
-		}
+	public static void writeToDisk(boolean generatePackagesStructure, String outputPath, String relativeFileName,
+			ClassFile classFile) throws IOException {
+		File file = getFile(generatePackagesStructure, outputPath, relativeFileName);
+		byte[] bytes = Arrays.copyOf(classFile.header, classFile.headerOffset + classFile.contentsOffset);
+		System.arraycopy(classFile.contents, 0, bytes, classFile.headerOffset, classFile.contentsOffset);
+		Files.write(file.toPath(), bytes);
 	}
+
 	@SuppressWarnings({ "rawtypes", "unchecked" })
 	public static void recordNestedType(ClassFile classFile, TypeBinding typeBinding) {
 		if (classFile.visitedTypes == null) {
diff --git a/org.eclipse.jdt.core.tests.builder/src/org/eclipse/jdt/core/tests/builder/BuildpathTests.java b/org.eclipse.jdt.core.tests.builder/src/org/eclipse/jdt/core/tests/builder/BuildpathTests.java
index bc9b6bf4d54..c612a3dd9ad 100644
--- a/org.eclipse.jdt.core.tests.builder/src/org/eclipse/jdt/core/tests/builder/BuildpathTests.java
+++ b/org.eclipse.jdt.core.tests.builder/src/org/eclipse/jdt/core/tests/builder/BuildpathTests.java
@@ -369,7 +369,7 @@ public void testChangeZIPArchive1() throws Exception {
 
 		env.addExternalJars(projectPath, Util.getJavaClassLibs());
 		env.addExternalJars(projectPath, new String[] {externalLib});
-
+		long lastModified = new File(externalLib).lastModified();
 		IPath root = env.getPackageFragmentRootPath(projectPath, ""); //$NON-NLS-1$
 		env.setOutputFolder(projectPath, "");
 
@@ -394,7 +394,7 @@ public void testChangeZIPArchive1() throws Exception {
 			},
 			externalLib,
 			CompilerOptions.getFirstSupportedJavaVersion());
-
+		new File(externalLib).setLastModified(lastModified + 1000); // make sure lastModified has changed
 		IJavaProject p = env.getJavaProject(projectPath);
 		p.getJavaModel().refreshExternalArchives(new IJavaElement[] {p}, null);
 
diff --git a/org.eclipse.jdt.core.tests.compiler/META-INF/MANIFEST.MF b/org.eclipse.jdt.core.tests.compiler/META-INF/MANIFEST.MF
index b0be23b6be1..d29180e65b5 100644
--- a/org.eclipse.jdt.core.tests.compiler/META-INF/MANIFEST.MF
+++ b/org.eclipse.jdt.core.tests.compiler/META-INF/MANIFEST.MF
@@ -27,6 +27,5 @@ Import-Package: jakarta.annotation;version="[2.1.0,3.0.0)",
  org.eclipse.jdt.internal.compiler.apt.dispatch
 Bundle-RequiredExecutionEnvironment: JavaSE-17
 Eclipse-BundleShape: dir
-Bundle-Activator: org.eclipse.jdt.core.tests.compiler.Activator
 Bundle-ActivationPolicy: lazy
 Automatic-Module-Name: org.eclipse.jdt.core.tests.compiler
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/Activator.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/Activator.java
deleted file mode 100644
index 45729f46ea7..00000000000
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/Activator.java
+++ /dev/null
@@ -1,52 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2013 Stephan Herrmann 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.core.tests.compiler;
-
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Plugin;
-import org.eclipse.core.runtime.Status;
-import org.osgi.framework.BundleContext;
-import org.osgi.framework.ServiceReference;
-
-/**
- * Make the PackageAdmin service accessible to tests.
- *
- * @deprecated uses deprecated class PackageAdmin.
- */
-@SuppressWarnings({ "unchecked", "rawtypes" })
-public class Activator extends Plugin {
-
-	private static final String PLUGIN_ID = "org.eclipse.jdt.core.tests.compiler";
-
-	static org.osgi.service.packageadmin.PackageAdmin packageAdmin = null;
-
-
-	public void start(BundleContext context) throws Exception {
-
-		ServiceReference ref= context.getServiceReference(org.osgi.service.packageadmin.PackageAdmin.class.getName());
-		if (ref!=null)
-			packageAdmin = (org.osgi.service.packageadmin.PackageAdmin)context.getService(ref);
-		else
-			getLog().log(new Status(IStatus.ERROR, PLUGIN_ID, "Failed to load PackageAdmin service. Will not be able to access bundles org.eclipse.jdt.annotation."));
-	}
-
-	public void stop(BundleContext context) throws Exception {
-		// nothing
-	}
-
-	public static org.osgi.service.packageadmin.PackageAdmin getPackageAdmin() {
-		return packageAdmin;
-	}
-
-}
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/AbstractNullAnnotationTest.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/AbstractNullAnnotationTest.java
index a66a72c4f1a..f569ec24e79 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/AbstractNullAnnotationTest.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/AbstractNullAnnotationTest.java
@@ -16,12 +16,14 @@
 import java.io.File;
 import java.io.IOException;
 import java.net.URL;
+import java.util.Arrays;
 import java.util.Map;
 import org.eclipse.core.runtime.FileLocator;
 import org.eclipse.core.runtime.Platform;
 import org.eclipse.jdt.core.JavaCore;
 import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
 import org.osgi.framework.Bundle;
+import org.osgi.framework.FrameworkUtil;
 
 @SuppressWarnings({ "unchecked", "rawtypes" })
 public abstract class AbstractNullAnnotationTest extends AbstractComparableTest {
@@ -81,9 +83,6 @@ protected void setUp() throws Exception {
 		setUpAnnotationLib();
 	}
 
-	/**
-	 * @deprecated indirectly uses deprecated class PackageAdmin
-	 */
 	protected void setUpAnnotationLib() throws IOException {
 		if (this.LIBS == null) {
 			String[] defaultLibs = getDefaultClassPaths();
@@ -91,6 +90,15 @@ protected void setUpAnnotationLib() throws IOException {
 			this.LIBS = new String[len+1];
 			System.arraycopy(defaultLibs, 0, this.LIBS, 0, len);
 			this.LIBS[len] = getAnnotationLibPath();
+
+			Bundle[] bundles = FrameworkUtil.getBundle(this.getClass()).getBundleContext().getBundles();
+			File bundleFile = Arrays.stream(bundles)
+					.filter(b -> "org.eclipse.jdt.annotation".equals(b.getSymbolicName())) //
+					.findFirst().flatMap(FileLocator::getBundleFileLocation).orElseThrow();
+			if (bundleFile.isDirectory())
+				this.LIBS[len] = bundleFile.getPath()+"/bin";
+			else
+				this.LIBS[len] = bundleFile.getPath();
 		}
 	}
 
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/BatchCompilerTest.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/BatchCompilerTest.java
index e09a12222ad..e32ac751369 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/BatchCompilerTest.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/BatchCompilerTest.java
@@ -68,7 +68,7 @@
 public class BatchCompilerTest extends AbstractBatchCompilerTest {
 
 	static {
-//		TESTS_NAMES = new String[] { "test440477" };
+//		TESTS_NAMES = new String[] { "test3445" };
 //		TESTS_NUMBERS = new int[] { 306 };
 //		TESTS_RANGE = new int[] { 298, -1 };
 	}
@@ -13161,4 +13161,47 @@ public void testGH2434(){
         "",
         true);
 }
+public void test3445() {
+	final String testScratchArea = "fileSystemTestScratchArea";
+
+	File testScratchAreaFile = new File(Util.getOutputDirectory(), testScratchArea);
+	File packsFile = null;
+	try {
+		if(!testScratchAreaFile.exists()) {
+			testScratchAreaFile.mkdirs();
+		}
+
+
+		assertTrue(testScratchAreaFile.exists());
+
+		String packComponent = "AAAA";
+		final String packs = packComponent + File.separator + packComponent + File.separator + packComponent;
+		 packsFile = new File(testScratchAreaFile,  packs);
+
+		try {
+			if(!packsFile.exists()) {
+				packsFile.mkdirs();
+			}
+		} finally {
+			// do nothing
+		}
+
+		Classpath classpath = FileSystem.getClasspath(testScratchAreaFile.getPath(), null, null);
+		assertNotNull(classpath);
+		assertTrue(classpath instanceof ClasspathDirectory);
+
+		ClasspathDirectory classpathDirectory = (ClasspathDirectory)classpath;
+		classpathDirectory.getModulesDeclaringPackage(packs, ""); // //Just testing the concurrenthashmap implementation.
+
+	} finally {
+		if(packsFile.exists()) {
+			Util.delete(packsFile);
+		}
+
+		if(testScratchAreaFile.exists()) {
+			Util.delete(testScratchAreaFile);
+		}
+	}
+}
+
 }
\ No newline at end of file
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/CharOperationTest.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/CharOperationTest.java
index a2164eba878..c61288c267d 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/CharOperationTest.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/CharOperationTest.java
@@ -170,4 +170,26 @@ public void test012() {
 			4,
 			true));
 }
+
+public void testReplacePerformance001() {
+	// This is the test that takes an excessively long time
+	// The improvement here is drastic, 99% reduction in time
+	testReplaceImpl("This is one line with no matches\n", 9, 0.01);
+}
+
+private void testReplaceImpl(String oneLine, int power, double multiplier) {
+	String total = oneLine;
+	for( int i = 0; i < power; i++ ) {
+		total = total + total; // Double the length
+	}
+	total = oneLine + total;
+
+	// Now replace
+	long start = System.currentTimeMillis();
+	char[] found = CharOperation.replace(total.toCharArray(), new char[]{'/'}, new char[] {'z'});
+	assertNotNull(found);
+	long end = System.currentTimeMillis();
+	long spent = end - start;
+	assertTrue(spent < 10);
+}
 }
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/CompilerInvocationTests.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/CompilerInvocationTests.java
index 96c45a4075c..51a1ec1e43d 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/CompilerInvocationTests.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/CompilerInvocationTests.java
@@ -1949,8 +1949,8 @@ class ProblemAttributes {
 		expectedProblemAttributes.put("LocalVariableIsNeverUsed", new ProblemAttributes(JavaCore.COMPILER_PB_UNUSED_LOCAL));
 		expectedProblemAttributes.put("LocalVariableMayBeNull", SKIP);
 		expectedProblemAttributes.put("MaskedCatch", new ProblemAttributes(JavaCore.COMPILER_PB_HIDDEN_CATCH_BLOCK));
-		expectedProblemAttributes.put("MandatoryCloseNotShown", new ProblemAttributes(JavaCore.COMPILER_PB_UNCLOSED_CLOSEABLE));
-		expectedProblemAttributes.put("MandatoryCloseNotShownAtExit", new ProblemAttributes(JavaCore.COMPILER_PB_UNCLOSED_CLOSEABLE));
+		expectedProblemAttributes.put("MandatoryCloseNotShown", new ProblemAttributes(JavaCore.COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE));
+		expectedProblemAttributes.put("MandatoryCloseNotShownAtExit", new ProblemAttributes(JavaCore.COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE));
 		expectedProblemAttributes.put("MessageSendWithUnresolvedOwningAnnotation", SKIP);
 		expectedProblemAttributes.put("MethodButWithConstructorName", new ProblemAttributes(JavaCore.COMPILER_PB_METHOD_WITH_CONSTRUCTOR_NAME));
 		expectedProblemAttributes.put("MethodCanBePotentiallyStatic", new ProblemAttributes(JavaCore.COMPILER_PB_POTENTIALLY_MISSING_STATIC_ON_METHOD));
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/NullAnnotationTest.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/NullAnnotationTest.java
index 766b7322421..e1c648a34e2 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/NullAnnotationTest.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/NullAnnotationTest.java
@@ -10931,7 +10931,12 @@ public void testBug548418_001a() {
 			"	^^^^^^^^\n" +
 			"Breaking out of switch expressions not permitted\n" +
 			"----------\n" +
-			"3. ERROR in X.java (at line 15)\n" +
+			"3. ERROR in X.java (at line 14)\n" +
+			"	}\n" +
+			"	^^\n" +
+			"A switch labeled block in a switch expression must yield a value or throw an an exception\n" +
+			"----------\n" +
+			"4. ERROR in X.java (at line 15)\n" +
 			"	default -> null;\n" +
 			"	           ^^^^\n" +
 			"Null type mismatch: required '@NonNull X' but the provided value is null\n" +
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/ResourceLeakAnnotatedTests.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/ResourceLeakAnnotatedTests.java
index 3915fcaaf81..86007908514 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/ResourceLeakAnnotatedTests.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/ResourceLeakAnnotatedTests.java
@@ -138,7 +138,7 @@ protected String getTest056e_log() {
 protected String getTest056y_log() {
 	return """
 			----------
-			1. ERROR in X.java (at line 4)
+			1. WARNING in X.java (at line 4)
 				final FileReader reader31 = new FileReader("file");
 				                 ^^^^^^^^
 			Mandatory close of resource 'reader31' has not been shown
@@ -199,6 +199,25 @@ protected String getTestBug440282_log() {
 		"----------\n";
 }
 
+@Override
+String getBug561334_log() {
+	// 1. info is only reported when annotations are enabled
+	// 2. warning is more severe since we set OWNED_BY_DEFAULT on the resource from getFoo()
+	return	"""
+			----------
+			1. INFO in Foo.java (at line 18)
+				foo = new Foo("Hello, world!");
+				      ^^^^^^^^^^^^^^^^^^^^^^^^
+			Mandatory close of resource '<unassigned Closeable value>' has not been shown
+			----------
+			2. WARNING in Foo.java (at line 21)
+				System.out.println(getFoo().thing);
+				                   ^^^^^^^^
+			Resource leak: '<unassigned Closeable value>' is never closed
+			----------
+			""";
+}
+
 public void testBug411098_comment19_annotated() {
 	runLeakTestWithAnnotations(
 		new String[] {
@@ -1798,8 +1817,8 @@ public void close() throws IOException {
 		},
 		"",
 		getCompilerOptions());
-	Util.delete(new File(OUTPUT_DIR, "org/eclipse/jdt/annotation/Owning.class".replaceAll("/", File.separator)));
-	Util.delete(new File(OUTPUT_DIR, "org/eclipse/jdt/annotation/NotOwning.class".replaceAll("/", File.separator)));
+	Util.delete(new File(OUTPUT_DIR, "org/eclipse/jdt/annotation/Owning.class".replace('/', File.separatorChar)));
+	Util.delete(new File(OUTPUT_DIR, "org/eclipse/jdt/annotation/NotOwning.class".replace('/', File.separatorChar)));
 
 	Map<String, String> options = getCompilerOptions();
 	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/ResourceLeakTests.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/ResourceLeakTests.java
index 88fc9f6b3ee..981d6a977c4 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/ResourceLeakTests.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/ResourceLeakTests.java
@@ -7295,4 +7295,52 @@ public static void main(String[] args) throws Exception {
 		""",
 		options);
 }
+public void testBug561334() {
+	Map<String, String> compilerOptions = getCompilerOptions();
+	compilerOptions.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.INFO);
+	runLeakWarningTest(
+		new String[] {
+			"Foo.java",
+			"""
+			public class Foo implements AutoCloseable {
+				private final String thing;
+				public Foo(String thing) {
+					this.thing = thing;
+				}
+
+				@Override
+				public void close() {
+					//
+				}
+
+				private static Foo foo;
+				private static Foo getFoo() {
+					return foo;
+				}
+
+				public static void main(String[] args) {
+					foo = new Foo("Hello, world!");
+					try {
+						System.out.println(foo.thing);
+						System.out.println(getFoo().thing);
+					} finally {
+						getFoo().close();
+					}
+				}
+			}
+			"""
+		},
+		getBug561334_log(),
+		compilerOptions);
+}
+String getBug561334_log() {
+	return """
+	----------
+	1. INFO in Foo.java (at line 21)
+		System.out.println(getFoo().thing);
+		                   ^^^^^^^^
+	Mandatory close of resource '<unassigned Closeable value>' has not been shown
+	----------
+	""";
+}
 }
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/SuperTypeTest.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/SuperTypeTest.java
index f420c75e9fc..de2f422df43 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/SuperTypeTest.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/SuperTypeTest.java
@@ -583,7 +583,7 @@ public void test017() {
 		"1. ERROR in X.java (at line 11)\n" +
 		"	public final class X extends Y implements IVerticalRulerColumn, IVerticalRulerInfo, IVerticalRulerInfoExtension {}\n" +
 		"	                                          ^^^^^^^^^^^^^^^^^^^^\n" +
-		"Redundant superinterface IVerticalRulerColumn for the type X, already defined by IRevisionRulerColumn\n" +
+		"Redundant superinterface IVerticalRulerColumn for the type X, already defined by IChangeRulerColumn\n" +
 		"----------\n" +
 		"2. ERROR in X.java (at line 11)\n" +
 		"	public final class X extends Y implements IVerticalRulerColumn, IVerticalRulerInfo, IVerticalRulerInfoExtension {}\n" +
@@ -593,7 +593,7 @@ public void test017() {
 		"3. ERROR in X.java (at line 11)\n" +
 		"	public final class X extends Y implements IVerticalRulerColumn, IVerticalRulerInfo, IVerticalRulerInfoExtension {}\n" +
 		"	                                                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
-		"Redundant superinterface IVerticalRulerInfoExtension for the type X, already defined by IRevisionRulerColumn\n" +
+		"Redundant superinterface IVerticalRulerInfoExtension for the type X, already defined by IChangeRulerColumn\n" +
 		"----------\n",
 		JavacTestOptions.SKIP);
 }
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/SwitchExpressionsYieldTest.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/SwitchExpressionsYieldTest.java
index 2f9c460523d..d8706501487 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/SwitchExpressionsYieldTest.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/SwitchExpressionsYieldTest.java
@@ -486,7 +486,7 @@ public void testBug544073_014() {
 					"1. ERROR in X.java (at line 8)\n" +
 					"	default :v = 2;\n" +
 					"	            ^^\n" +
-					"A switch labeled block in a switch expression should not complete normally\n" +
+					"A switch labeled block in a switch expression must yield a value or throw an an exception\n" +
 					"----------\n";
 			this.runNegativeTest(
 					testFiles,
@@ -2127,6 +2127,11 @@ public void testBug544073_076() {
 			"	continue;\n" +
 			"	^^^^^^^^^\n" +
 			"Continue out of switch expressions not permitted\n" +
+			"----------\n" +
+			"2. ERROR in X.java (at line 11)\n" +
+			"	continue;\n" +
+			"	       ^^\n" +
+			"A switch labeled block in a switch expression must yield a value or throw an an exception\n" +
 			"----------\n");
 	}
 	public void testBug544073_077() {
@@ -4989,7 +4994,7 @@ public void testBug562728_005() {
 		"1. ERROR in X.java (at line 9)\n" +
 		"	default :v = 2;\n" +
 		"	            ^^\n" +
-		"A switch labeled block in a switch expression should not complete normally\n" +
+		"A switch labeled block in a switch expression must yield a value or throw an an exception\n" +
 		"----------\n");
 	}
 	public void testBug562728_006() {
@@ -5021,12 +5026,12 @@ public void testBug562728_006() {
 		"1. ERROR in X.java (at line 8)\n" +
 		"	case 2 ->{v = 2;}\n" +
 		"	               ^^\n" +
-		"A switch labeled block in a switch expression should not complete normally\n" +
+		"A switch labeled block in a switch expression must yield a value or throw an an exception\n" +
 		"----------\n" +
 		"2. ERROR in X.java (at line 9)\n" +
 		"	default ->{v = 2;}\n" +
 		"	                ^^\n" +
-		"A switch labeled block in a switch expression should not complete normally\n" +
+		"A switch labeled block in a switch expression must yield a value or throw an an exception\n" +
 		"----------\n");
 	}
     public void testBug562728_007() {
@@ -5113,7 +5118,7 @@ public void testBug563023_002() {
 		"1. ERROR in X.java (at line 13)\n" +
 		"	}\n" +
 		"	^^\n" +
-		"A switch labeled block in a switch expression should not complete normally\n" +
+		"A switch labeled block in a switch expression must yield a value or throw an an exception\n" +
         "----------\n");
 }
     public void testBug563023_003() {
@@ -5142,7 +5147,7 @@ public void testBug563023_003() {
 		"1. ERROR in X.java (at line 10)\n" +
 		"	}\n" +
 		"	^^\n" +
-		"A switch labeled block in a switch expression should not complete normally\n" +
+		"A switch labeled block in a switch expression must yield a value or throw an an exception\n" +
         "----------\n");
 }
     public void testBug563023_004() {
@@ -5202,7 +5207,7 @@ public void testBug563023_005() {
 		"1. ERROR in X.java (at line 11)\n" +
 		"	}\n" +
 		"	^^\n" +
-		"A switch labeled block in a switch expression should not complete normally\n" +
+		"A switch labeled block in a switch expression must yield a value or throw an an exception\n" +
         "----------\n");
 }
 	public void testBug563023_006() {
@@ -5269,7 +5274,7 @@ public void testBug563023_007() {
 		"2. ERROR in X.java (at line 10)\n" +
 		"	}\n" +
 		"	^^\n" +
-		"A switch labeled block in a switch expression should not complete normally\n" +
+		"A switch labeled block in a switch expression must yield a value or throw an an exception\n" +
         "----------\n");
 }
 	public void testBug563147_001() {
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/SwitchPatternTest.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/SwitchPatternTest.java
index 41c57a40c3e..eeb4c248931 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/SwitchPatternTest.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/SwitchPatternTest.java
@@ -104,7 +104,7 @@ protected void runWarningTest(String[] testFiles, String expectedCompilerLog,
 		runner.runWarningTest();
 	}
 
-	private static void verifyClassFile(String expectedOutput, String classFileName, int mode)
+	private static void verifyClassFile(String expectedOutput, String unexpectedOutput, String classFileName, int mode)
 			throws IOException, ClassFormatException {
 		File f = new File(OUTPUT_DIR + File.separator + classFileName);
 		byte[] classFileBytes = org.eclipse.jdt.internal.compiler.util.Util.getFileByteContent(f);
@@ -118,6 +118,15 @@ private static void verifyClassFile(String expectedOutput, String classFileName,
 		if (index == -1) {
 			assertEquals("Wrong contents", expectedOutput, result);
 		}
+		if (unexpectedOutput != null) {
+			index = result.indexOf(unexpectedOutput);
+			assertTrue("Unexpected output found", index == -1);
+		}
+	}
+
+	private static void verifyClassFile(String expectedOutput, String classFileName, int mode)
+			throws IOException, ClassFormatException {
+		verifyClassFile(expectedOutput, null, classFileName, mode);
 	}
 	public void testIssue57_001() {
 		runConformTest(
@@ -1841,7 +1850,7 @@ public void testBug573940_5() {
 				"1. ERROR in X.java (at line 6)\n" +
 				"	}\n" +
 				"	^^\n" +
-				"A switch labeled block in a switch expression should not complete normally\n" +
+				"A switch labeled block in a switch expression must yield a value or throw an an exception\n" +
 				"----------\n");
 	}
 	public void testBug574564_001() {
@@ -4902,7 +4911,7 @@ public void testBug578568_3() {
 				"1. ERROR in X.java (at line 11)\n" +
 				"	}\n" +
 				"	^^\n" +
-				"A switch labeled block in a switch expression should not complete normally\n" +
+				"A switch labeled block in a switch expression must yield a value or throw an an exception\n" +
 				"----------\n");
 	}
 	public void testBug578416() {
@@ -9628,4 +9637,37 @@ public static void main(String[] args) {
 				"World--Check--Hello--Null--Default--\n" +
 				"Default--Null--Hello--Check--World--");
 	}
+
+	// https://github.com/eclipse-jdt/eclipse.jdt.core/issues/3447
+	// [Enhanced Switch] Wasteful generation of switch ordinal mapping table for enum switches that are dispatched via enumSwitch indy
+	public void testIssue3447() throws Exception {
+		runConformTest(
+			new String[] {
+				"X.java",
+				"""
+				enum E {
+					A,
+					B,
+				}
+
+				public class X {
+					public static void main(String[] args) {
+						E e = E.A;
+						switch (e) {
+							case A :    System.out.println("A");
+									    break;
+							case B:     System.out.println("B");
+							            break;
+							case null : System.out.println("null");
+										break;
+						}
+					}
+				}
+				"""
+			},
+		 "A");
+		String expectedOutput = "8  invokedynamic 0 enumSwitch(E, int) : int [22]\n";
+		String unexpectedOutput = "static synthetic int[] $SWITCH_TABLE$E();\n";
+		SwitchPatternTest.verifyClassFile(expectedOutput, unexpectedOutput, "X.class", ClassFileBytesDisassembler.SYSTEM);
+	}
 }
diff --git a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/RunVariousSwitchTests.java b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/RunVariousSwitchTests.java
index f51e9b1345f..d2cd13ec528 100644
--- a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/RunVariousSwitchTests.java
+++ b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/RunVariousSwitchTests.java
@@ -51,6 +51,12 @@ public static Class[] getAllTestClasses() {
 				LocalEnumTest.class,
 				ConstantTest.class,
 
+				NullAnnotationTests21.class,
+				NullAnnotationTest.class,
+
+				PrimitiveInPatternsTest.class,
+				PrimitiveInPatternsTestSH.class,
+
 				JavaSearchBugs14SwitchExpressionTests.class,
 				ASTRewritingSwitchExpressionsTest.class,
 				ASTRewritingSwitchPatternTest.class,
diff --git a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/JavaSearchBugsTests.java b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/JavaSearchBugsTests.java
index c94bfd7a45f..a20875f92ce 100644
--- a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/JavaSearchBugsTests.java
+++ b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/JavaSearchBugsTests.java
@@ -10737,11 +10737,14 @@ public void run() {
 		    }
 		};
 		Thread thread = new Thread(search);
+		long start = System.nanoTime();
+		long maxEnd = start + 10_000_000_000L;
+
 		thread.start();
 
 		// Delete project in current thread after being sure that the search
 		// request was started
-		while (requestor.count < (MAX/3)) {
+		while (requestor.count < (MAX/3) && System.nanoTime() < maxEnd) {
 			Thread.sleep(10);
 		}
 		deleteProject(javaProject);
diff --git a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/OwningAnnotationModelTests.java b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/OwningAnnotationModelTests.java
index f47c9e319a2..763112ad2c2 100644
--- a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/OwningAnnotationModelTests.java
+++ b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/OwningAnnotationModelTests.java
@@ -160,6 +160,7 @@ public void close() throws Exception {
 
 			IJavaProject p2 = createJavaProject("P2", new String[] {""}, new String[] {"JCL_23_LIB"}, "bin", "23");
 			p2.setOption(JavaCore.COMPILER_ANNOTATION_RESOURCE_ANALYSIS, JavaCore.ENABLED);
+			p2.setOption(JavaCore.COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE, JavaCore.WARNING);
 			addClasspathEntry(p2, JavaCore.newProjectEntry(p1.getPath())); // no access to the annotation lib, since not re-exported
 
 			createFolder("/P2/client");
@@ -469,6 +470,7 @@ public void close() throws Exception {
 
 			IJavaProject p2 = createJavaProject("P2", new String[] {""}, new String[] {"JCL_23_LIB"}, "bin", "23");
 			p2.setOption(JavaCore.COMPILER_ANNOTATION_RESOURCE_ANALYSIS, JavaCore.ENABLED);
+			p2.setOption(JavaCore.COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE, JavaCore.WARNING);
 			addClasspathEntry(p2, JavaCore.newProjectEntry(p1.getPath())); // no access to the annotation lib, since not re-exported
 
 			createFolder("/P2/client");
diff --git a/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/DeltaProcessor.java b/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/DeltaProcessor.java
index f62651f5ecf..d21fd3a5d00 100644
--- a/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/DeltaProcessor.java
+++ b/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/DeltaProcessor.java
@@ -226,7 +226,7 @@ public String toString() {
 	 * Used for detecting external JAR changes
 	 */
 	public static long getTimeStamp(File file) {
-		return file.lastModified() + file.length();
+		return file.lastModified() + Long.hashCode(file.length()) * 31;
 	}
 
 	/*