From iris at openjdk.org Tue Aug 1 01:48:54 2023 From: iris at openjdk.org (Iris Clark) Date: Tue, 1 Aug 2023 01:48:54 GMT Subject: [jdk21] RFR: 8039165: [Doc] MessageFormat null locale generates NullPointerException In-Reply-To: References: Message-ID: On Mon, 31 Jul 2023 21:13:16 GMT, Justin Lu wrote: > Please review this change which contains a backport of commit [c6396dce](https://github.com/openjdk/jdk/commit/c6396dceb9a64578d5b335af27ad1d968190a1fa) from the [openjdk/jdk](https://git.openjdk.org/jdk) repository. > > This PR is a java.text doc/test-only change. > > The commit being backported was authored by Justin Lu on 25 Jul 2023 and was reviewed by Naoto Sato. > > Thanks! Marked as reviewed by iris (Reviewer). ------------- PR Review: https://git.openjdk.org/jdk21/pull/154#pullrequestreview-1556044570 From naoto at openjdk.org Tue Aug 1 20:21:11 2023 From: naoto at openjdk.org (Naoto Sato) Date: Tue, 1 Aug 2023 20:21:11 GMT Subject: RFR: 8309622: Re-examine the cache mechanism in BaseLocale [v5] In-Reply-To: <5MqmN4P1TLKDCfXPhKWrH1b2FTgOXmjtKgd1bVXDd_M=.2000f20d-365d-48dc-bc37-45d8bcb9447f@github.com> References: <5MqmN4P1TLKDCfXPhKWrH1b2FTgOXmjtKgd1bVXDd_M=.2000f20d-365d-48dc-bc37-45d8bcb9447f@github.com> Message-ID: > This is stemming from the PR: https://github.com/openjdk/jdk/pull/14211 where aggressive GC can cause NPE in `BaseLocale$Key` class. I refactored the in-house cache with WeakHashMap, and removed the Key class as it is no longer needed (thus the original NPE will no longer be possible). Also with the new JMH test case, it gains some performance improvement: > > (w/o fix) > > Benchmark Mode Cnt Score Error Units > LocaleCache.testForLanguageTag avgt 20 5781.275 ? 569.580 ns/op > LocaleCache.testLocaleOf avgt 20 62564.079 ? 406.697 ns/op > > (w/ fix) > Benchmark Mode Cnt Score Error Units > LocaleCache.testForLanguageTag avgt 20 4801.175 ? 371.830 ns/op > LocaleCache.testLocaleOf avgt 20 60394.652 ? 352.471 ns/op Naoto Sato has updated the pull request with a new target base due to a merge or a rebase. The pull request now contains 29 commits: - Merge branch 'master' of https://git.openjdk.org/jdk into JDK-8309622-Cache-BaseLocale - small cleanup - Merge branch 'pull/14684' into JDK-8309622-Cache-BaseLocale - Update ReferencedKeyTest.java - Simple versions of create - Add flag for reference queue type - Merge branch 'master' into 8310913 - Update to use VirtualThread friendly stale queue. - Merge branch 'pull/14684' into JDK-8309622-Cache-BaseLocale - Remove warning tied to String Templates - ... and 19 more: https://git.openjdk.org/jdk/compare/7ba8c69a...0e435898 ------------- Changes: https://git.openjdk.org/jdk/pull/14404/files Webrev: https://webrevs.openjdk.org/?repo=jdk&pr=14404&range=04 Stats: 697 lines in 7 files changed: 129 ins; 441 del; 127 mod Patch: https://git.openjdk.org/jdk/pull/14404.diff Fetch: git fetch https://git.openjdk.org/jdk.git pull/14404/head:pull/14404 PR: https://git.openjdk.org/jdk/pull/14404 From jlu at openjdk.org Tue Aug 1 23:04:04 2023 From: jlu at openjdk.org (Justin Lu) Date: Tue, 1 Aug 2023 23:04:04 GMT Subject: [jdk21] Integrated: 8039165: [Doc] MessageFormat null locale generates NullPointerException In-Reply-To: References: Message-ID: On Mon, 31 Jul 2023 21:13:16 GMT, Justin Lu wrote: > Please review this change which contains a backport of commit [c6396dce](https://github.com/openjdk/jdk/commit/c6396dceb9a64578d5b335af27ad1d968190a1fa) from the [openjdk/jdk](https://git.openjdk.org/jdk) repository. > > This PR is a java.text doc/test-only change. > > The commit being backported was authored by Justin Lu on 25 Jul 2023 and was reviewed by Naoto Sato. > > Thanks! This pull request has now been integrated. Changeset: f34ac12a Author: Justin Lu URL: https://git.openjdk.org/jdk21/commit/f34ac12aa7c2b932bf2f4c7a58e4dfdf228edfd2 Stats: 164 lines in 3 files changed: 97 ins; 64 del; 3 mod 8039165: [Doc] MessageFormat null locale generates NullPointerException Reviewed-by: naoto, iris Backport-of: c6396dceb9a64578d5b335af27ad1d968190a1fa ------------- PR: https://git.openjdk.org/jdk21/pull/154 From naoto at openjdk.org Wed Aug 2 23:29:52 2023 From: naoto at openjdk.org (Naoto Sato) Date: Wed, 2 Aug 2023 23:29:52 GMT Subject: RFR: 8041488: Locale-Dependent List Patterns Message-ID: Introducing a new formatting class for locale-dependent list patterns. The class is to provide the functionality from the Unicode Consortium's LDML specification for [list patterns](https://www.unicode.org/reports/tr35/tr35-general.html#ListPatterns). For example, given a list of String as "Monday", "Wednesday", "Friday", its `format` method would produce "Monday, Wednesday, and Friday" in US English. A CSR has also been drafted, and its draft javadoc can be viewed here: https://cr.openjdk.org/~naoto/JDK-8041488-ListPatterns-PR/api.00/java.base/java/text/ListFormat.html ------------- Commit messages: - Initial commit Changes: https://git.openjdk.org/jdk/pull/15130/files Webrev: https://webrevs.openjdk.org/?repo=jdk&pr=15130&range=00 Issue: https://bugs.openjdk.org/browse/JDK-8041488 Stats: 679 lines in 6 files changed: 671 ins; 0 del; 8 mod Patch: https://git.openjdk.org/jdk/pull/15130.diff Fetch: git fetch https://git.openjdk.org/jdk.git pull/15130/head:pull/15130 PR: https://git.openjdk.org/jdk/pull/15130 From jlu at openjdk.org Wed Aug 2 23:32:23 2023 From: jlu at openjdk.org (Justin Lu) Date: Wed, 2 Aug 2023 23:32:23 GMT Subject: RFR: 8174722: Wrong behavior of DecimalFormat with RoundingMode.UP in special case [v3] In-Reply-To: References: Message-ID: > Please review this PR, which addresses a case where Decimal Format would violate certain RoundingMode contracts given the right pattern and input decimal String. > > For example, > > > DecimalFormat df = new DecimalFormat(); > df.setRoundingMode(RoundingMode.UP); > double small = 0.0001; > double big = 1.0001; > df.applyPattern("0.00"); > df.format(small); // returns 0.00, which violates UP > df.format(big); // returns 1.01, which does not violate UP > > > In this example `0.0001` becomes `0.00`, a decrease in magnitude. This violates the RoundingMode.UP contract as RoundingMode.UP states "Note that this rounding mode never decreases the magnitude of the calculated value." > > This edge case is a result of when input decimal String values smaller than the absolute value of `.1` have more leading zeros between the decimal and the first non-zero digit (_0.0001 -> **3**_) than maximum fractional digits in the pattern (_0.00 -> **2**_). > > The test validates the change by using data from larger counterparts. For example, If we are testing `0.0009`, we can format `1.0009` with the same pattern and mode that we use on `0.0009`, then compare the fractional portions to each other and ensure they are equal. Justin Lu has updated the pull request incrementally with one additional commit since the last revision: Refactor underflowToZero ------------- Changes: - all: https://git.openjdk.org/jdk/pull/14110/files - new: https://git.openjdk.org/jdk/pull/14110/files/a8e1a81b..ed889741 Webrevs: - full: https://webrevs.openjdk.org/?repo=jdk&pr=14110&range=02 - incr: https://webrevs.openjdk.org/?repo=jdk&pr=14110&range=01-02 Stats: 39 lines in 1 file changed: 2 ins; 22 del; 15 mod Patch: https://git.openjdk.org/jdk/pull/14110.diff Fetch: git fetch https://git.openjdk.org/jdk.git pull/14110/head:pull/14110 PR: https://git.openjdk.org/jdk/pull/14110 From naoto at openjdk.org Wed Aug 2 23:40:31 2023 From: naoto at openjdk.org (Naoto Sato) Date: Wed, 2 Aug 2023 23:40:31 GMT Subject: RFR: 8041488: Locale-Dependent List Patterns [v2] In-Reply-To: References: Message-ID: > Introducing a new formatting class for locale-dependent list patterns. The class is to provide the functionality from the Unicode Consortium's LDML specification for [list patterns](https://www.unicode.org/reports/tr35/tr35-general.html#ListPatterns). For example, given a list of String as "Monday", "Wednesday", "Friday", its `format` method would produce "Monday, Wednesday, and Friday" in US English. A CSR has also been drafted, and its draft javadoc can be viewed here: https://cr.openjdk.org/~naoto/JDK-8041488-ListPatterns-PR/api.00/java.base/java/text/ListFormat.html Naoto Sato has updated the pull request incrementally with one additional commit since the last revision: Added test ------------- Changes: - all: https://git.openjdk.org/jdk/pull/15130/files - new: https://git.openjdk.org/jdk/pull/15130/files/7340a0f7..8e7181f2 Webrevs: - full: https://webrevs.openjdk.org/?repo=jdk&pr=15130&range=01 - incr: https://webrevs.openjdk.org/?repo=jdk&pr=15130&range=00-01 Stats: 207 lines in 1 file changed: 207 ins; 0 del; 0 mod Patch: https://git.openjdk.org/jdk/pull/15130.diff Fetch: git fetch https://git.openjdk.org/jdk.git pull/15130/head:pull/15130 PR: https://git.openjdk.org/jdk/pull/15130 From jlu at openjdk.org Thu Aug 3 16:38:36 2023 From: jlu at openjdk.org (Justin Lu) Date: Thu, 3 Aug 2023 16:38:36 GMT Subject: RFR: 8313702: Update IANA Language Subtag Registry to Version 2023-08-02 Message-ID: Please review this PR which updates the IANA data from version 05-11-2023 to version [08-02-2023](https://mm.icann.org/pipermail/ietf-languages-announcements/2023-August/000088.html). The contents of the update added variant subtag ?blasl? to the language subtag registry. ------------- Commit messages: - Support 08-02-23 Changes: https://git.openjdk.org/jdk/pull/15142/files Webrev: https://webrevs.openjdk.org/?repo=jdk&pr=15142&range=00 Issue: https://bugs.openjdk.org/browse/JDK-8313702 Stats: 12 lines in 2 files changed: 9 ins; 0 del; 3 mod Patch: https://git.openjdk.org/jdk/pull/15142.diff Fetch: git fetch https://git.openjdk.org/jdk.git pull/15142/head:pull/15142 PR: https://git.openjdk.org/jdk/pull/15142 From naoto at openjdk.org Thu Aug 3 18:48:30 2023 From: naoto at openjdk.org (Naoto Sato) Date: Thu, 3 Aug 2023 18:48:30 GMT Subject: RFR: 8313702: Update IANA Language Subtag Registry to Version 2023-08-02 In-Reply-To: References: Message-ID: On Thu, 3 Aug 2023 16:31:01 GMT, Justin Lu wrote: > Please review this PR which updates the IANA data from version 05-11-2023 to version [08-02-2023](https://mm.icann.org/pipermail/ietf-languages-announcements/2023-August/000088.html). > > The contents of the update added variant subtag ?blasl? to the language subtag registry. Marked as reviewed by naoto (Reviewer). ------------- PR Review: https://git.openjdk.org/jdk/pull/15142#pullrequestreview-1561671988 From iris at openjdk.org Thu Aug 3 20:27:29 2023 From: iris at openjdk.org (Iris Clark) Date: Thu, 3 Aug 2023 20:27:29 GMT Subject: RFR: 8313702: Update IANA Language Subtag Registry to Version 2023-08-02 In-Reply-To: References: Message-ID: On Thu, 3 Aug 2023 16:31:01 GMT, Justin Lu wrote: > Please review this PR which updates the IANA data from version 05-11-2023 to version [08-02-2023](https://mm.icann.org/pipermail/ietf-languages-announcements/2023-August/000088.html). > > The contents of the update added variant subtag ?blasl? to the language subtag registry. Marked as reviewed by iris (Reviewer). ------------- PR Review: https://git.openjdk.org/jdk/pull/15142#pullrequestreview-1561806378 From naoto at openjdk.org Thu Aug 3 21:25:45 2023 From: naoto at openjdk.org (Naoto Sato) Date: Thu, 3 Aug 2023 21:25:45 GMT Subject: RFR: 8041488: Locale-Dependent List Patterns [v3] In-Reply-To: References: Message-ID: > Introducing a new formatting class for locale-dependent list patterns. The class is to provide the functionality from the Unicode Consortium's LDML specification for [list patterns](https://www.unicode.org/reports/tr35/tr35-general.html#ListPatterns). For example, given a list of String as "Monday", "Wednesday", "Friday", its `format` method would produce "Monday, Wednesday, and Friday" in US English. A CSR has also been drafted, and its draft javadoc can be viewed here: https://cr.openjdk.org/~naoto/JDK-8041488-ListPatterns-PR/api.00/java.base/java/text/ListFormat.html Naoto Sato has updated the pull request incrementally with one additional commit since the last revision: Wording fixes ------------- Changes: - all: https://git.openjdk.org/jdk/pull/15130/files - new: https://git.openjdk.org/jdk/pull/15130/files/8e7181f2..cf3dddba Webrevs: - full: https://webrevs.openjdk.org/?repo=jdk&pr=15130&range=02 - incr: https://webrevs.openjdk.org/?repo=jdk&pr=15130&range=01-02 Stats: 3 lines in 1 file changed: 0 ins; 0 del; 3 mod Patch: https://git.openjdk.org/jdk/pull/15130.diff Fetch: git fetch https://git.openjdk.org/jdk.git pull/15130/head:pull/15130 PR: https://git.openjdk.org/jdk/pull/15130 From naoto at openjdk.org Fri Aug 4 21:09:13 2023 From: naoto at openjdk.org (Naoto Sato) Date: Fri, 4 Aug 2023 21:09:13 GMT Subject: RFR: 8041488: Locale-Dependent List Patterns [v4] In-Reply-To: References: Message-ID: > Introducing a new formatting class for locale-dependent list patterns. The class is to provide the functionality from the Unicode Consortium's LDML specification for [list patterns](https://www.unicode.org/reports/tr35/tr35-general.html#ListPatterns). For example, given a list of String as "Monday", "Wednesday", "Friday", its `format` method would produce "Monday, Wednesday, and Friday" in US English. A CSR has also been drafted, and its draft javadoc can be viewed here: https://cr.openjdk.org/~naoto/JDK-8041488-ListPatterns-PR/api.00/java.base/java/text/ListFormat.html Naoto Sato has updated the pull request incrementally with one additional commit since the last revision: parsePosition update ------------- Changes: - all: https://git.openjdk.org/jdk/pull/15130/files - new: https://git.openjdk.org/jdk/pull/15130/files/cf3dddba..50ba267c Webrevs: - full: https://webrevs.openjdk.org/?repo=jdk&pr=15130&range=03 - incr: https://webrevs.openjdk.org/?repo=jdk&pr=15130&range=02-03 Stats: 42 lines in 2 files changed: 40 ins; 1 del; 1 mod Patch: https://git.openjdk.org/jdk/pull/15130.diff Fetch: git fetch https://git.openjdk.org/jdk.git pull/15130/head:pull/15130 PR: https://git.openjdk.org/jdk/pull/15130 From jlu at openjdk.org Mon Aug 7 17:13:39 2023 From: jlu at openjdk.org (Justin Lu) Date: Mon, 7 Aug 2023 17:13:39 GMT Subject: Integrated: 8313702: Update IANA Language Subtag Registry to Version 2023-08-02 In-Reply-To: References: Message-ID: On Thu, 3 Aug 2023 16:31:01 GMT, Justin Lu wrote: > Please review this PR which updates the IANA data from version 05-11-2023 to version [08-02-2023](https://mm.icann.org/pipermail/ietf-languages-announcements/2023-August/000088.html). > > The contents of the update added variant subtag ?blasl? to the language subtag registry. This pull request has now been integrated. Changeset: 1da82a34 Author: Justin Lu URL: https://git.openjdk.org/jdk/commit/1da82a34b14189814e45a93c68620ccb51427111 Stats: 12 lines in 2 files changed: 9 ins; 0 del; 3 mod 8313702: Update IANA Language Subtag Registry to Version 2023-08-02 Reviewed-by: naoto, iris ------------- PR: https://git.openjdk.org/jdk/pull/15142 From naoto at openjdk.org Tue Aug 8 17:19:55 2023 From: naoto at openjdk.org (Naoto Sato) Date: Tue, 8 Aug 2023 17:19:55 GMT Subject: RFR: 8041488: Locale-Dependent List Patterns [v5] In-Reply-To: References: Message-ID: <9S5QinT9cgHGGL26AXkWN8ENRVxL1Le1fwZ_rdTz-F4=.684308dc-e1b8-4dee-9eff-3690b327e29b@github.com> > Introducing a new formatting class for locale-dependent list patterns. The class is to provide the functionality from the Unicode Consortium's LDML specification for [list patterns](https://www.unicode.org/reports/tr35/tr35-general.html#ListPatterns). For example, given a list of String as "Monday", "Wednesday", "Friday", its `format` method would produce "Monday, Wednesday, and Friday" in US English. A CSR has also been drafted, and its draft javadoc can be viewed here: https://cr.openjdk.org/~naoto/JDK-8041488-ListPatterns-PR/api.00/java.base/java/text/ListFormat.html Naoto Sato has updated the pull request with a new target base due to a merge or a rebase. The incremental webrev excludes the unrelated changes brought in by the merge/rebase. The pull request contains five additional commits since the last revision: - Merge branch 'master' into JDK-8041488-ListPatterns-PR - parsePosition update - Wording fixes - Added test - Initial commit ------------- Changes: - all: https://git.openjdk.org/jdk/pull/15130/files - new: https://git.openjdk.org/jdk/pull/15130/files/50ba267c..a98e1e1f Webrevs: - full: https://webrevs.openjdk.org/?repo=jdk&pr=15130&range=04 - incr: https://webrevs.openjdk.org/?repo=jdk&pr=15130&range=03-04 Stats: 8981 lines in 435 files changed: 3504 ins; 2284 del; 3193 mod Patch: https://git.openjdk.org/jdk/pull/15130.diff Fetch: git fetch https://git.openjdk.org/jdk.git pull/15130/head:pull/15130 PR: https://git.openjdk.org/jdk/pull/15130 From rriggs at openjdk.org Tue Aug 8 20:01:41 2023 From: rriggs at openjdk.org (Roger Riggs) Date: Tue, 8 Aug 2023 20:01:41 GMT Subject: RFR: 8041488: Locale-Dependent List Patterns [v5] In-Reply-To: <9S5QinT9cgHGGL26AXkWN8ENRVxL1Le1fwZ_rdTz-F4=.684308dc-e1b8-4dee-9eff-3690b327e29b@github.com> References: <9S5QinT9cgHGGL26AXkWN8ENRVxL1Le1fwZ_rdTz-F4=.684308dc-e1b8-4dee-9eff-3690b327e29b@github.com> Message-ID: On Tue, 8 Aug 2023 17:19:55 GMT, Naoto Sato wrote: >> Introducing a new formatting class for locale-dependent list patterns. The class is to provide the functionality from the Unicode Consortium's LDML specification for [list patterns](https://www.unicode.org/reports/tr35/tr35-general.html#ListPatterns). For example, given a list of String as "Monday", "Wednesday", "Friday", its `format` method would produce "Monday, Wednesday, and Friday" in US English. A CSR has also been drafted, and its draft javadoc can be viewed here: https://cr.openjdk.org/~naoto/JDK-8041488-ListPatterns-PR/api.00/java.base/java/text/ListFormat.html > > Naoto Sato has updated the pull request with a new target base due to a merge or a rebase. The incremental webrev excludes the unrelated changes brought in by the merge/rebase. The pull request contains five additional commits since the last revision: > > - Merge branch 'master' into JDK-8041488-ListPatterns-PR > - parsePosition update > - Wording fixes > - Added test > - Initial commit src/java.base/share/classes/java/text/ListFormat.java line 199: > 197: * @param locale Locale to be used, not null > 198: * @param type type of the list format. One of STANDARD/OR/UNIT, not null > 199: * @param style style of the list format. One of FULL/SHORT/NARROW, not null It would be ease navigation in the javadoc if there was a link to the ListFormat.Type and ListFormat.Style classes, perhaps Locale also. Use the normal prose form STANDARD, OR, or UNIT, instead of the "/" shorthand. Here and throughout the javadoc. Ditto FULL, SHORT, or NARROW. Also use Locale, Type, and Style instead of the shorthand. src/java.base/share/classes/java/text/ListFormat.java line 213: > 211: /** > 212: * {@return the list format for the specified patterns} > 213: *

LDML includes a section on the "Gender of Lists"; If later support was desired, is this API extensible to include that? https://www.unicode.org/reports/tr35/tr35-general.html#List_Gender src/java.base/share/classes/java/text/ListFormat.java line 234: > 232: * If parsing of the pattern string for start/middle/end fails, it throws an > 233: * {@code IllegalArgumentException}. If two/three pattern string is empty, or > 234: * fails on parsing, it falls back to I don't see code to try to parse the TWO or THREE patterns, where it could detect incorrectly formatted (user supplied) patterns. If I understand correctly, a bad TWO or THREE pattern would not be detected until it is used in format or parse. src/java.base/share/classes/java/text/ListFormat.java line 350: > 348: * {@code "a", "b", "c"}. > 349: * > 350: * @param source the String to parse, not null. String does not need to be capitalized. src/java.base/share/classes/java/text/ListFormat.java line 365: > 363: > 364: /** > 365: * Parses text from a string to produce a list of {@code String}s. No need to capitalize String if list is not capitalized. (or be consistent) src/java.base/share/classes/java/text/ListFormat.java line 428: > 426: return Arrays.asList(objs); > 427: } > 428: throw new InternalError("MessageFormat.parseObject() should return Object[]"); The error message is inconsistent with line 426, returning a List. src/java.base/share/classes/java/text/ListFormat.java line 442: > 440: > 441: /** > 442: * {@inheritDoc} The javadoc from Object.equals doesn't give any information about what constituted equals for a ListFormat. Namely, that the locale and patterns are equal. src/java.base/share/classes/java/text/ListFormat.java line 480: > 478: var len = input.length; > 479: return switch (len) { > 480: case 0 -> throw new IllegalArgumentException("There should at least be one input string"); It is unfortunate that LDML did not consider the case of an empty list. For example, to supply "NONE" or "n/a" or similar. The developer will need to deal with that separately. ------------- PR Review Comment: https://git.openjdk.org/jdk/pull/15130#discussion_r1287548046 PR Review Comment: https://git.openjdk.org/jdk/pull/15130#discussion_r1287623678 PR Review Comment: https://git.openjdk.org/jdk/pull/15130#discussion_r1287564928 PR Review Comment: https://git.openjdk.org/jdk/pull/15130#discussion_r1287624574 PR Review Comment: https://git.openjdk.org/jdk/pull/15130#discussion_r1287626211 PR Review Comment: https://git.openjdk.org/jdk/pull/15130#discussion_r1287627985 PR Review Comment: https://git.openjdk.org/jdk/pull/15130#discussion_r1287630232 PR Review Comment: https://git.openjdk.org/jdk/pull/15130#discussion_r1287622614 From naoto at openjdk.org Tue Aug 8 21:45:33 2023 From: naoto at openjdk.org (Naoto Sato) Date: Tue, 8 Aug 2023 21:45:33 GMT Subject: RFR: 8041488: Locale-Dependent List Patterns [v5] In-Reply-To: References: <9S5QinT9cgHGGL26AXkWN8ENRVxL1Le1fwZ_rdTz-F4=.684308dc-e1b8-4dee-9eff-3690b327e29b@github.com> Message-ID: <-DjQ2TurFbzd3vc0Iz2AHv0EfjCvLJRsU2c5XC8acPo=.c79bef39-07f5-4bef-b4c7-44bfbbdb82f7@github.com> On Tue, 8 Aug 2023 19:49:19 GMT, Roger Riggs wrote: >> Naoto Sato has updated the pull request with a new target base due to a merge or a rebase. The incremental webrev excludes the unrelated changes brought in by the merge/rebase. The pull request contains five additional commits since the last revision: >> >> - Merge branch 'master' into JDK-8041488-ListPatterns-PR >> - parsePosition update >> - Wording fixes >> - Added test >> - Initial commit > > src/java.base/share/classes/java/text/ListFormat.java line 213: > >> 211: /** >> 212: * {@return the list format for the specified patterns} >> 213: *

> > LDML includes a section on the "Gender of Lists"; If later support was desired, is this API extensible to include that? https://www.unicode.org/reports/tr35/tr35-general.html#List_Gender IIUC, although it is described within "list patterns" in LDML, it is orthogonal to "list patterns." The purpose of the "Gender of Lists" seems to me the resulting gender of the whole list of names, e.g., "Tom and Mary" is "other" in English, but it is "male" in Arabic (I just used the sample XML in the spec). So I believe it is not an extension of the class. > src/java.base/share/classes/java/text/ListFormat.java line 234: > >> 232: * If parsing of the pattern string for start/middle/end fails, it throws an >> 233: * {@code IllegalArgumentException}. If two/three pattern string is empty, or >> 234: * fails on parsing, it falls back to > > I don't see code to try to parse the TWO or THREE patterns, where it could detect incorrectly formatted (user supplied) patterns. > If I understand correctly, a bad TWO or THREE pattern would not be detected until it is used in format or parse. Right. Will provide validation for them > src/java.base/share/classes/java/text/ListFormat.java line 442: > >> 440: >> 441: /** >> 442: * {@inheritDoc} > > The javadoc from Object.equals doesn't give any information about what constituted equals for a ListFormat. > Namely, that the locale and patterns are equal. Will add those ListFormat specific considerations. ------------- PR Review Comment: https://git.openjdk.org/jdk/pull/15130#discussion_r1287716917 PR Review Comment: https://git.openjdk.org/jdk/pull/15130#discussion_r1287716871 PR Review Comment: https://git.openjdk.org/jdk/pull/15130#discussion_r1287717003 From naoto at openjdk.org Tue Aug 8 22:21:04 2023 From: naoto at openjdk.org (Naoto Sato) Date: Tue, 8 Aug 2023 22:21:04 GMT Subject: RFR: 8041488: Locale-Dependent List Patterns [v6] In-Reply-To: References: Message-ID: > Introducing a new formatting class for locale-dependent list patterns. The class is to provide the functionality from the Unicode Consortium's LDML specification for [list patterns](https://www.unicode.org/reports/tr35/tr35-general.html#ListPatterns). For example, given a list of String as "Monday", "Wednesday", "Friday", its `format` method would produce "Monday, Wednesday, and Friday" in US English. A CSR has also been drafted, and its draft javadoc can be viewed here: https://cr.openjdk.org/~naoto/JDK-8041488-ListPatterns-PR/api.00/java.base/java/text/ListFormat.html Naoto Sato has updated the pull request incrementally with one additional commit since the last revision: Reflects review comments ------------- Changes: - all: https://git.openjdk.org/jdk/pull/15130/files - new: https://git.openjdk.org/jdk/pull/15130/files/a98e1e1f..516c00c7 Webrevs: - full: https://webrevs.openjdk.org/?repo=jdk&pr=15130&range=05 - incr: https://webrevs.openjdk.org/?repo=jdk&pr=15130&range=04-05 Stats: 59 lines in 2 files changed: 40 ins; 1 del; 18 mod Patch: https://git.openjdk.org/jdk/pull/15130.diff Fetch: git fetch https://git.openjdk.org/jdk.git pull/15130/head:pull/15130 PR: https://git.openjdk.org/jdk/pull/15130 From naoto at openjdk.org Wed Aug 9 00:46:58 2023 From: naoto at openjdk.org (Naoto Sato) Date: Wed, 9 Aug 2023 00:46:58 GMT Subject: RFR: 8041488: Locale-Dependent List Patterns [v7] In-Reply-To: References: Message-ID: <1rFouxpbzGLybnxXGslNTnoMIZC7MjrEU1zvDCKaqi0=.d3566682-582f-4a26-81c2-76f35f6fed5c@github.com> > Introducing a new formatting class for locale-dependent list patterns. The class is to provide the functionality from the Unicode Consortium's LDML specification for [list patterns](https://www.unicode.org/reports/tr35/tr35-general.html#ListPatterns). For example, given a list of String as "Monday", "Wednesday", "Friday", its `format` method would produce "Monday, Wednesday, and Friday" in US English. A CSR has also been drafted, and its draft javadoc can be viewed here: https://cr.openjdk.org/~naoto/JDK-8041488-ListPatterns-PR/api.00/java.base/java/text/ListFormat.html Naoto Sato has updated the pull request incrementally with one additional commit since the last revision: Small cleanup ------------- Changes: - all: https://git.openjdk.org/jdk/pull/15130/files - new: https://git.openjdk.org/jdk/pull/15130/files/516c00c7..7760656a Webrevs: - full: https://webrevs.openjdk.org/?repo=jdk&pr=15130&range=06 - incr: https://webrevs.openjdk.org/?repo=jdk&pr=15130&range=05-06 Stats: 4 lines in 1 file changed: 0 ins; 2 del; 2 mod Patch: https://git.openjdk.org/jdk/pull/15130.diff Fetch: git fetch https://git.openjdk.org/jdk.git pull/15130/head:pull/15130 PR: https://git.openjdk.org/jdk/pull/15130 From joehw at openjdk.org Thu Aug 10 00:03:58 2023 From: joehw at openjdk.org (Joe Wang) Date: Thu, 10 Aug 2023 00:03:58 GMT Subject: RFR: 8041488: Locale-Dependent List Patterns [v7] In-Reply-To: <1rFouxpbzGLybnxXGslNTnoMIZC7MjrEU1zvDCKaqi0=.d3566682-582f-4a26-81c2-76f35f6fed5c@github.com> References: <1rFouxpbzGLybnxXGslNTnoMIZC7MjrEU1zvDCKaqi0=.d3566682-582f-4a26-81c2-76f35f6fed5c@github.com> Message-ID: On Wed, 9 Aug 2023 00:46:58 GMT, Naoto Sato wrote: >> Introducing a new formatting class for locale-dependent list patterns. The class is to provide the functionality from the Unicode Consortium's LDML specification for [list patterns](https://www.unicode.org/reports/tr35/tr35-general.html#ListPatterns). For example, given a list of String as "Monday", "Wednesday", "Friday", its `format` method would produce "Monday, Wednesday, and Friday" in US English. A CSR has also been drafted, and its draft javadoc can be viewed here: https://cr.openjdk.org/~naoto/JDK-8041488-ListPatterns-PR/api.00/java.base/java/text/ListFormat.html > > Naoto Sato has updated the pull request incrementally with one additional commit since the last revision: > > Small cleanup src/java.base/share/classes/java/text/ListFormat.java line 58: > 56: * .format(List.of("Foo", "Bar", "Baz")) > 57: * } > 58: * This will produce the concatenated list string, "Foo, Bar, and Baz" as seen in With this sample code, if the Style is changed to SHORT, it would produce the same string. Would it be better to use the weekdays instead of Foo, Bar and Baz (as in the Unicode spec)? Esp. with the UNIT type, those examples explained it better, e.g. NARROW produces 3? 7?. Also, if the instance is of STANDARD/SHORT, does it format List.of("January", "February", "March") and return "Jan., Feb., and Mar.", or 3 feet, 7 inches to 3 ft, 7 in? The format method states simply "Returns the string that consists of the input strings, concatenated with the patterns of this ListFormat." I wonder if it'd be helpful to explain a bit more or add one more sample. src/java.base/share/classes/java/text/ListFormat.java line 71: > 69: * STANDARD > 70: * Foo, Bar, and Baz > 71: * Foo, Bar, & Baz Is "&" a typo? It's still "and" in the Unicode spec's "standard-short" format, e.g. "Jan., Feb., and Mar." src/java.base/share/classes/java/text/ListFormat.java line 408: > 406: var em = endPattern.matcher(source); > 407: Object parsed = null; > 408: if (sm.find(parsePos.index) && em.find(parsePos.index)) { Would it be better to call getIndex() instead? (same below) test/jdk/java/text/Format/ListFormat/TestListFormat.java line 157: > 155: "foo, bar, baz", true), > 156: arguments(Locale.US, ListFormat.Type.OR, ListFormat.Style.NARROW, > 157: "foo, bar, or baz", true), Same as in the ListFormat class, the expected results are the same "foo, bar, or baz" when different Styles are specified. ------------- PR Review Comment: https://git.openjdk.org/jdk/pull/15130#discussion_r1289362909 PR Review Comment: https://git.openjdk.org/jdk/pull/15130#discussion_r1289364452 PR Review Comment: https://git.openjdk.org/jdk/pull/15130#discussion_r1289352495 PR Review Comment: https://git.openjdk.org/jdk/pull/15130#discussion_r1289365866 From naoto at openjdk.org Thu Aug 10 17:31:28 2023 From: naoto at openjdk.org (Naoto Sato) Date: Thu, 10 Aug 2023 17:31:28 GMT Subject: RFR: 8041488: Locale-Dependent List Patterns [v8] In-Reply-To: References: Message-ID: > Introducing a new formatting class for locale-dependent list patterns. The class is to provide the functionality from the Unicode Consortium's LDML specification for [list patterns](https://www.unicode.org/reports/tr35/tr35-general.html#ListPatterns). For example, given a list of String as "Monday", "Wednesday", "Friday", its `format` method would produce "Monday, Wednesday, and Friday" in US English. A CSR has also been drafted, and its draft javadoc can be viewed here: https://cr.openjdk.org/~naoto/JDK-8041488-ListPatterns-PR/api.00/java.base/java/text/ListFormat.html Naoto Sato has updated the pull request incrementally with one additional commit since the last revision: Reflecting review comments ------------- Changes: - all: https://git.openjdk.org/jdk/pull/15130/files - new: https://git.openjdk.org/jdk/pull/15130/files/7760656a..5b536fab Webrevs: - full: https://webrevs.openjdk.org/?repo=jdk&pr=15130&range=07 - incr: https://webrevs.openjdk.org/?repo=jdk&pr=15130&range=06-07 Stats: 4 lines in 1 file changed: 2 ins; 0 del; 2 mod Patch: https://git.openjdk.org/jdk/pull/15130.diff Fetch: git fetch https://git.openjdk.org/jdk.git pull/15130/head:pull/15130 PR: https://git.openjdk.org/jdk/pull/15130 From naoto at openjdk.org Thu Aug 10 17:34:59 2023 From: naoto at openjdk.org (Naoto Sato) Date: Thu, 10 Aug 2023 17:34:59 GMT Subject: RFR: 8041488: Locale-Dependent List Patterns [v7] In-Reply-To: References: <1rFouxpbzGLybnxXGslNTnoMIZC7MjrEU1zvDCKaqi0=.d3566682-582f-4a26-81c2-76f35f6fed5c@github.com> Message-ID: <67BVzHBTdGjXFSXWq06oYJ_RcWGNc0E01jQO2RvWp1w=.c66ffd69-25a5-484c-8aa8-c6d548363857@github.com> On Wed, 9 Aug 2023 23:39:24 GMT, Joe Wang wrote: >> Naoto Sato has updated the pull request incrementally with one additional commit since the last revision: >> >> Small cleanup > > src/java.base/share/classes/java/text/ListFormat.java line 58: > >> 56: * .format(List.of("Foo", "Bar", "Baz")) >> 57: * } >> 58: * This will produce the concatenated list string, "Foo, Bar, and Baz" as seen in > > With this sample code, if the Style is changed to SHORT, it would produce the same string. Would it be better to use the weekdays instead of Foo, Bar and Baz (as in the Unicode spec)? Esp. with the UNIT type, those examples explained it better, e.g. NARROW produces 3? 7?. > > Also, if the instance is of STANDARD/SHORT, does it format List.of("January", "February", "March") and return "Jan., Feb., and Mar.", or 3 feet, 7 inches to 3 ft, 7 in? The format method states simply "Returns the string that consists of the input strings, concatenated with the patterns of this ListFormat." I wonder if it'd be helpful to explain a bit more or add one more sample. In fact, the sample in LDML's page seems to be incorrect. `standard-short` in English is defined as: {0}, {1} {0}, {1} {0}, & {1} {0} & {1} in `en.xml` file. So `&` is expected rather than `and`. > Also, if the instance is of STANDARD/SHORT, does it format List.of("January", "February", "March") and return "Jan., Feb., and Mar.", or 3 feet, 7 inches to 3 ft, 7 in? No it does not. The `format()` method does not alter the passed input strings, so it would not convert "January" to "Jan." even if `SHORT` Style is specified. I have added some extra explanations, that those patterns vary depending on the locale providers. > src/java.base/share/classes/java/text/ListFormat.java line 71: > >> 69: * STANDARD >> 70: * Foo, Bar, and Baz >> 71: * Foo, Bar, & Baz > > Is "&" a typo? It's still "and" in the Unicode spec's "standard-short" format, e.g. "Jan., Feb., and Mar." Again `ampersand` is the correct pattern for `SHORT` in English. > src/java.base/share/classes/java/text/ListFormat.java line 408: > >> 406: var em = endPattern.matcher(source); >> 407: Object parsed = null; >> 408: if (sm.find(parsePos.index) && em.find(parsePos.index)) { > > Would it be better to call getIndex() instead? (same below) Fixed. > test/jdk/java/text/Format/ListFormat/TestListFormat.java line 157: > >> 155: "foo, bar, baz", true), >> 156: arguments(Locale.US, ListFormat.Type.OR, ListFormat.Style.NARROW, >> 157: "foo, bar, or baz", true), > > Same as in the ListFormat class, the expected results are the same "foo, bar, or baz" when different Styles are specified. Yes, those are exactly what are defined in CLDR. (They could have chosen `|` for SHORT style, but that would be not so common in plain English I guess) ------------- PR Review Comment: https://git.openjdk.org/jdk/pull/15130#discussion_r1290428317 PR Review Comment: https://git.openjdk.org/jdk/pull/15130#discussion_r1290428359 PR Review Comment: https://git.openjdk.org/jdk/pull/15130#discussion_r1290428267 PR Review Comment: https://git.openjdk.org/jdk/pull/15130#discussion_r1290428459 From joehw at openjdk.org Thu Aug 10 22:02:58 2023 From: joehw at openjdk.org (Joe Wang) Date: Thu, 10 Aug 2023 22:02:58 GMT Subject: RFR: 8041488: Locale-Dependent List Patterns [v7] In-Reply-To: <67BVzHBTdGjXFSXWq06oYJ_RcWGNc0E01jQO2RvWp1w=.c66ffd69-25a5-484c-8aa8-c6d548363857@github.com> References: <1rFouxpbzGLybnxXGslNTnoMIZC7MjrEU1zvDCKaqi0=.d3566682-582f-4a26-81c2-76f35f6fed5c@github.com> <67BVzHBTdGjXFSXWq06oYJ_RcWGNc0E01jQO2RvWp1w=.c66ffd69-25a5-484c-8aa8-c6d548363857@github.com> Message-ID: On Thu, 10 Aug 2023 16:59:14 GMT, Naoto Sato wrote: >> src/java.base/share/classes/java/text/ListFormat.java line 58: >> >>> 56: * .format(List.of("Foo", "Bar", "Baz")) >>> 57: * } >>> 58: * This will produce the concatenated list string, "Foo, Bar, and Baz" as seen in >> >> With this sample code, if the Style is changed to SHORT, it would produce the same string. Would it be better to use the weekdays instead of Foo, Bar and Baz (as in the Unicode spec)? Esp. with the UNIT type, those examples explained it better, e.g. NARROW produces 3? 7?. >> >> Also, if the instance is of STANDARD/SHORT, does it format List.of("January", "February", "March") and return "Jan., Feb., and Mar.", or 3 feet, 7 inches to 3 ft, 7 in? The format method states simply "Returns the string that consists of the input strings, concatenated with the patterns of this ListFormat." I wonder if it'd be helpful to explain a bit more or add one more sample. > > In fact, the sample in LDML's page seems to be incorrect. `standard-short` in English is defined as: > > > {0}, {1} > {0}, {1} > {0}, & {1} > {0} & {1} > > > in `en.xml` file. So `&` is expected rather than `and`. > >> Also, if the instance is of STANDARD/SHORT, does it format List.of("January", "February", "March") and return "Jan., Feb., and Mar.", or 3 feet, 7 inches to 3 ft, 7 in? > > No it does not. The `format()` method does not alter the passed input strings, so it would not convert "January" to "Jan." even if `SHORT` Style is specified. I have added some extra explanations, that those patterns vary depending on the locale providers. Ah, I see. Those samples did give an impression that the format does more than concatenation. ------------- PR Review Comment: https://git.openjdk.org/jdk/pull/15130#discussion_r1290711203 From erikj at openjdk.org Fri Aug 18 14:30:54 2023 From: erikj at openjdk.org (Erik Joelsson) Date: Fri, 18 Aug 2023 14:30:54 GMT Subject: RFR: 8314483: Optionally override copyright header in generated source Message-ID: In the JDK build we have various build tools that generate source code from data files. For most of these tools, the source files are based on template files, which already have copyright headers, but for some, the complete source file is generated by the tool, which is providing the copyright header programatically. For the latter, we would like to implement an override mechanism in each tool so that we can change the copyright header from a custom makefile. ------------- Commit messages: - JDK-8314483 Changes: https://git.openjdk.org/jdk/pull/15346/files Webrev: https://webrevs.openjdk.org/?repo=jdk&pr=15346&range=00 Issue: https://bugs.openjdk.org/browse/JDK-8314483 Stats: 43 lines in 4 files changed: 34 ins; 1 del; 8 mod Patch: https://git.openjdk.org/jdk/pull/15346.diff Fetch: git fetch https://git.openjdk.org/jdk.git pull/15346/head:pull/15346 PR: https://git.openjdk.org/jdk/pull/15346 From rriggs at openjdk.org Fri Aug 18 20:06:38 2023 From: rriggs at openjdk.org (Roger Riggs) Date: Fri, 18 Aug 2023 20:06:38 GMT Subject: RFR: 8041488: Locale-Dependent List Patterns [v8] In-Reply-To: References: Message-ID: On Thu, 10 Aug 2023 17:31:28 GMT, Naoto Sato wrote: >> Introducing a new formatting class for locale-dependent list patterns. The class is to provide the functionality from the Unicode Consortium's LDML specification for [list patterns](https://www.unicode.org/reports/tr35/tr35-general.html#ListPatterns). For example, given a list of String as "Monday", "Wednesday", "Friday", its `format` method would produce "Monday, Wednesday, and Friday" in US English. A CSR has also been drafted, and its draft javadoc can be viewed here: https://cr.openjdk.org/~naoto/JDK-8041488-ListPatterns-PR/api.00/java.base/java/text/ListFormat.html > > Naoto Sato has updated the pull request incrementally with one additional commit since the last revision: > > Reflecting review comments src/java.base/share/classes/java/text/ListFormat.java line 96: > 94: * round-trip with the corresponding formatting. For example, a String list > 95: * "a, b,", "c" will be formatted as "a, b, and c", but may be parsed as > 96: * "a", "b", "c". Suggestion: * round-trip with the corresponding formatting. For example, a two element String list * "a, b,", "c" will be formatted as "a, b, and c", but may be parsed as three elements * "a", "b", "c". src/java.base/share/classes/java/text/ListFormat.java line 240: > 238: * is thrown. > 239: *

> 240: * Each pattern string is first parsed as follows. Patterns in parentheses are optional: The characters in parentheses are arbitrary and literal strings; not really "patterns" in the regex sense. src/java.base/share/classes/java/text/ListFormat.java line 246: > 244: * end := {0}end_between{1}(end_after) > 245: * two := (two_before){0}two_between{1}(two_after) > 246: * three := (three_before){0}three_between{1}three_between{2}(three_after) The use of "three_between" in 2 positions may mislead the developer to think they need to be the same string. Perhaps "three_between1" and "three_between2"? or something to differentiate them. src/java.base/share/classes/java/text/ListFormat.java line 250: > 248: * If parsing of the pattern string for start/middle/end fails, it throws an > 249: * {@code IllegalArgumentException}. If two/three pattern string is empty, or > 250: * fails on parsing, it falls back to The IllegalArgumentException is thrown for a parse failure on any of the start, middle, end, two, or three patterns. The fallback is only if they are null or empty. A more readable form of "start/middle/end" would be "start, middle, or end". Here and elsewhere in the javadoc. src/java.base/share/classes/java/text/ListFormat.java line 262: > 260: * n > 3: (start_before){0}start_between{1}middle_between{2} ... middle_between{m}end_between{n}(end_after) > 261: * > 262: * As an example, the following table shows patterns array which is equivalent to Suggestion: * As an example, the following table shows a pattern array which is equivalent to src/java.base/share/classes/java/text/ListFormat.java line 279: > 277: * 2 > 278: * "{0} and {1}" > 279: * 3 The use of different terms to identify pattern kinds of 2/two and 3/three may be confusing. Unless it is referring to LDML, use "two" and "three" be used consistently. src/java.base/share/classes/java/text/ListFormat.java line 304: > 302: * @param patterns array of patterns, not null > 303: * @throws IllegalArgumentException if the length {@code patterns} array is not 5, or > 304: * any of {@code start}, {@code middle}, {@code end} patterns cannot be parsed. Also throws if two and three patterns can not be parsed. src/java.base/share/classes/java/text/ListFormat.java line 353: > 351: return generateMessageFormat(a).format(a, toAppendTo, DontCareFieldPosition.INSTANCE); > 352: } else { > 353: throw new IllegalArgumentException("The object to format should be an Object list"); Suggestion: throw new IllegalArgumentException("The object to format should be a List