8177819: DateTimeFormatterBuilder zone parsing should recognise DST

src/java.base/share/classes/java/time/format/DateTimeFormatter.java

@@ -504,8 +504,9 @@
  * If a {@code ZoneId} was parsed without an offset then the zone will be
  * combined with the {@code LocalDateTime} to form the instant using the rules
  * of {@link ChronoLocalDateTime#atZone(ZoneId)}. If the {@code ZoneId} was
- * parsed from the zone name that does not indicate daylight saving time, then
- * the standard offset will be used at the local time-line overlap.
+ * parsed from a zone name that indicates whether daylight saving time is in
+ * operation or not, then that fact will be used to select the correct offset
+ * at the local time-line overlap.
  * </ol>
  *
  * @implSpec

src/java.base/share/classes/java/time/format/DateTimeFormatterBuilder.java

@@ -4668,9 +4668,6 @@ private PrefixTree(String k, String v, int type, PrefixTree child) {
          * @return the tree, not null
          */
         public static PrefixTree newTree(DateTimeParseContext context) {
-            //if (!context.isStrict()) {
-            //    return new LENIENT("", null, null);
-            //}
             if (context.isCaseSensitive()) {
                 return new PrefixTree("", null, ZoneTextPrinterParser.UNDEFINED, null);
             }
@@ -4896,86 +4893,6 @@ protected boolean prefixOf(CharSequence text, int off, int end) {
                 return true;
             }
         }
-
-        /**
-         * Lenient prefix tree. Case insensitive and ignores characters
-         * like space, underscore and slash.
-         */
-        private static class LENIENT extends CI {
-
-            private LENIENT(String k, String v, int t, PrefixTree child) {
-                super(k, v, t, child);
-            }
-
-            @Override
-            protected CI newNode(String k, String v, int t, PrefixTree child) {
-                return new LENIENT(k, v, t, child);
-            }
-
-            private boolean isLenientChar(char c) {
-                return c == ' ' || c == '_' || c == '/';
-            }
-
-            protected String toKey(String k) {
-                for (int i = 0; i < k.length(); i++) {
-                    if (isLenientChar(k.charAt(i))) {
-                        StringBuilder sb = new StringBuilder(k.length());
-                        sb.append(k, 0, i);
-                        i++;
-                        while (i < k.length()) {
-                            if (!isLenientChar(k.charAt(i))) {
-                                sb.append(k.charAt(i));
-                            }
-                            i++;
-                        }
-                        return sb.toString();
-                    }
-                }
-                return k;
-            }
-
-            @Override
-            public PrefixTree match(CharSequence text, ParsePosition pos) {
-                int off = pos.getIndex();
-                int end = text.length();
-                int len = key.length();
-                int koff = 0;
-                while (koff < len && off < end) {
-                    if (isLenientChar(text.charAt(off))) {
-                        off++;
-                        continue;
-                    }
-                    if (!isEqual(key.charAt(koff++), text.charAt(off++))) {
-                        return null;
-                    }
-                }
-                if (koff != len) {
-                    return null;
-                }
-                if (child != null && off != end) {
-                    int off0 = off;
-                    while (off0 < end && isLenientChar(text.charAt(off0))) {
-                        off0++;
-                    }
-                    if (off0 < end) {
-                        PrefixTree c = child;
-                        do {
-                            if (isEqual(c.c0, text.charAt(off0))) {
-                                pos.setIndex(off0);
-                                PrefixTree found = c.match(text, pos);
-                                if (found != null) {
-                                    return found;
-                                }
-                                break;
-                            }
-                            c = c.sibling;
-                        } while (c != null);
-                    }
-                }
-                pos.setIndex(off);
-                return this;
-            }
-        }
     }
 
     //-----------------------------------------------------------------------

test/jdk/java/time/test/java/time/format/TestZoneTextPrinterParser.java

@@ -24,10 +24,12 @@
 package test.java.time.format;
 
 import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.fail;
 
 import java.text.DateFormatSymbols;
 import java.time.ZoneId;
 import java.time.ZonedDateTime;
+import java.time.format.DateTimeParseException;
 import java.time.format.DecimalStyle;
 import java.time.format.DateTimeFormatter;
 import java.time.format.DateTimeFormatterBuilder;
@@ -259,5 +261,14 @@ Object[][] data_roundTripAtOverlap() {
     public void test_roundTripAtOverlap(String pattern, String input) {
         var dtf = DateTimeFormatter.ofPattern(pattern);
         assertEquals(dtf.format(ZonedDateTime.parse(input, dtf)), input);
+        var lc = input.toLowerCase(Locale.ROOT);
+        try {
+            ZonedDateTime.parse(lc, dtf);
+            fail("Should throw DateTimeParseException");
+        } catch (DateTimeParseException ignore) {}
+
+        dtf = new DateTimeFormatterBuilder().parseCaseInsensitive().appendPattern(pattern).toFormatter();
+        assertEquals(dtf.format(ZonedDateTime.parse(input, dtf)), input);
+        assertEquals(dtf.format(ZonedDateTime.parse(lc, dtf)), input);
     }
 }