[GR-32375] Temporal Interop JS-to-Java.

PullRequest: js/2474

Author: wirthi

CHANGELOG.md

@@ -9,6 +9,7 @@ See [version roadmap](https://www.graalvm.org/release-notes/version-roadmap/) fo
 * GraalVM JavaScript is now an installable component of GraalVM. It can be installed with `gu install js`.
 * Removed experimental option `commonjs-global-properties`. The same functionality can be achieved in user code with a direct call to `require()` after context creation.
 * Added an experimental option `--js.zone-rules-based-time-zones` that allows to use timezone-related data from `ZoneRulesProvider` (instead of ICU4J data files).
+* Temporal objects can be converted to compatible Java objects when possible, using the `Value` API's methods like `asDate()`.
 
 ## Version 22.1.0
 * Updated Node.js to version 16.14.2.

graal-js/src/com.oracle.truffle.js.test/src/com/oracle/truffle/js/test/builtins/TemporalBuiltinsTest.java

@@ -1070,6 +1070,31 @@ public void testTimeSpecWithOptionalTimeZoneNotAmbiguous() {
         testTrue(code);
     }
 
+    @Test
+    public void testDuration1DayExactly24Hours() {
+        // DST was entered on 2022-03-27 at 1am, jumping to 2am
+        String code = "var dur = Temporal.Duration.from('P1D');\n" +
+                        "var relTo = Temporal.ZonedDateTime.from('2022-03-26T12:00+01:00[Europe/Vienna]'); \n" +
+                        "var dur2 = dur.round({ 'relativeTo': relTo, 'largestUnit': 'seconds' }); \n" +
+                        "dur2.seconds === 82800;"; // 23 hours
+        testTrue(code);
+
+        // same DST transition as above, but using 24 HOURS instead of 1 DAY
+        code = "var dur = Temporal.Duration.from('PT24H');\n" +
+                        "var relTo = Temporal.ZonedDateTime.from('2022-03-26T12:00+01:00[Europe/Vienna]'); \n" +
+                        "var dur2 = dur.round({ 'relativeTo': relTo, 'largestUnit': 'seconds' }); \n" +
+                        "dur2.seconds === 86400;"; // 24 hours, different than above. 1D != 24H
+        testTrue(code);
+
+        // There was one leap second at 2016-12-31 after 23:59:59 (UTC+0)
+        code = "var dur = Temporal.Duration.from('P1D');\n" +
+                        "var relTo = Temporal.ZonedDateTime.from('2016-12-31T12:00:00+00:00[Europe/London]'); \n" +
+                        "var dur2 = dur.round({ 'relativeTo': relTo, 'largestUnit': 'seconds' }); \n" +
+                        "dur2.seconds === 86400"; // exactly 1 day; Temporal does not consider leap
+                                                  // seconds
+        testTrue(code);
+    }
+
     private static void testTrue(String code) {
         try (Context ctx = getJSContext()) {
             Value result = ctx.eval(ID, code);

graal-js/src/com.oracle.truffle.js.test/src/com/oracle/truffle/js/test/interop/TemporalInteropToJavaTest.java

@@ -0,0 +1,227 @@
+/*
+ * Copyright (c) 2022, 2022, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * The Universal Permissive License (UPL), Version 1.0
+ *
+ * Subject to the condition set forth below, permission is hereby granted to any
+ * person obtaining a copy of this software, associated documentation and/or
+ * data (collectively the "Software"), free of charge and under any and all
+ * copyright rights in the Software, and any and all patent rights owned or
+ * freely licensable by each licensor hereunder covering either (i) the
+ * unmodified Software as contributed to or provided by such licensor, or (ii)
+ * the Larger Works (as defined below), to deal in both
+ *
+ * (a) the Software, and
+ *
+ * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if
+ * one is included with the Software each a "Larger Work" to which the Software
+ * is contributed by such licensors),
+ *
+ * without restriction, including without limitation the rights to copy, create
+ * derivative works of, display, perform, and distribute the Software and make,
+ * use, sell, offer for sale, import, export, have made, and have sold the
+ * Software and the Larger Work(s), and to sublicense the foregoing rights on
+ * either these or other terms.
+ *
+ * This license is subject to the following condition:
+ *
+ * The above copyright notice and either this complete permission notice or at a
+ * minimum a reference to the UPL must be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.oracle.truffle.js.test.interop;
+
+import static com.oracle.truffle.js.lang.JavaScriptLanguage.ID;
+
+import java.time.Duration;
+import java.time.Instant;
+import java.time.LocalDate;
+import java.time.LocalTime;
+import java.time.Month;
+import java.time.ZoneId;
+import java.time.ZoneOffset;
+
+import org.graalvm.polyglot.Context;
+import org.graalvm.polyglot.Value;
+import org.junit.Assert;
+import org.junit.Test;
+
+import com.oracle.truffle.js.test.JSTest;
+
+public class TemporalInteropToJavaTest extends JSTest {
+
+    private static Context getJSContext() {
+        return JSTest.newContextBuilder(ID).option("js.temporal", "true").build();
+    }
+
+    // Calendar, PlainMonthDay, PlainYearMonth cannot be converted to Instant, Date or Time
+
+    @Test
+    public void testInstant() {
+        try (Context ctx = getJSContext()) {
+            Value val = ctx.eval(ID, "new Temporal.Instant(0n);");
+            Instant inst = val.asInstant();
+            Assert.assertEquals(0, inst.getNano());
+            Assert.assertEquals(0, inst.getEpochSecond());
+        }
+
+        try (Context ctx = getJSContext()) {
+            Value val = ctx.eval(ID, "new Temporal.Instant(100_000_000n);");
+            Instant inst = val.asInstant();
+            Assert.assertEquals(100_000_000L, inst.getNano());
+            Assert.assertEquals(0, inst.getEpochSecond());
+        }
+
+        try (Context ctx = getJSContext()) {
+            Value val = ctx.eval(ID, "new Temporal.Instant(100_123_456_789n);");
+            Instant inst = val.asInstant();
+            Assert.assertEquals(123_456_789L, inst.getNano());
+            Assert.assertEquals(100, inst.getEpochSecond());
+
+            LocalDate ld = val.asDate();
+            Assert.assertEquals(1970, ld.getYear());
+            Assert.assertEquals(Month.JANUARY, ld.getMonth());
+            Assert.assertEquals(1, ld.getDayOfYear());
+
+            LocalTime lt = val.asTime();
+            Assert.assertEquals(0, lt.getHour());
+            Assert.assertEquals(1, lt.getMinute());
+            Assert.assertEquals(40, lt.getSecond());
+            Assert.assertEquals(123_456_789L, lt.getNano());
+
+            ZoneId zid = val.asTimeZone();
+            Assert.assertEquals("UTC", zid.getId());
+        }
+    }
+
+    @Test
+    public void testPlainDate() {
+        try (Context ctx = getJSContext()) {
+            Value val = ctx.eval(ID, "new Temporal.PlainDate(1982, 11, 26);");
+            LocalDate ld = val.asDate();
+            Assert.assertEquals(1982, ld.getYear());
+            Assert.assertEquals(Month.NOVEMBER, ld.getMonth());
+            Assert.assertEquals(26, ld.getDayOfMonth());
+
+            Assert.assertFalse(val.isTime());
+            Assert.assertFalse(val.isTimeZone());
+        }
+    }
+
+    @Test
+    public void testPlainTime() {
+        try (Context ctx = getJSContext()) {
+            Value val = ctx.eval(ID, "new Temporal.PlainTime(12, 34, 56, 987, 654, 321);");
+            LocalTime lt = val.asTime();
+            Assert.assertEquals(12, lt.getHour());
+            Assert.assertEquals(34, lt.getMinute());
+            Assert.assertEquals(56, lt.getSecond());
+            Assert.assertEquals(987_654_321L, lt.getNano());
+
+            Assert.assertFalse(val.isDate());
+            Assert.assertFalse(val.isTimeZone());
+        }
+    }
+
+    @Test
+    public void testPlainDateTime() {
+        try (Context ctx = getJSContext()) {
+            Value val = ctx.eval(ID, "new Temporal.PlainDateTime(1982, 11, 26, 12, 34, 56, 987, 654, 321);");
+            LocalDate ld = val.asDate();
+            Assert.assertEquals(1982, ld.getYear());
+            Assert.assertEquals(Month.NOVEMBER, ld.getMonth());
+            Assert.assertEquals(26, ld.getDayOfMonth());
+
+            LocalTime lt = val.asTime();
+            Assert.assertEquals(12, lt.getHour());
+            Assert.assertEquals(34, lt.getMinute());
+            Assert.assertEquals(56, lt.getSecond());
+            Assert.assertEquals(987_654_321L, lt.getNano());
+
+            Assert.assertFalse(val.isTimeZone());
+        }
+    }
+
+    @Test
+    public void testTimeZone() {
+        try (Context ctx = getJSContext()) {
+            Value val = ctx.eval(ID, "new Temporal.TimeZone('UTC');");
+            ZoneId zid = val.asTimeZone();
+            Assert.assertEquals("UTC", zid.getId());
+        }
+
+        try (Context ctx = getJSContext()) {
+            Value val = ctx.eval(ID, "new Temporal.TimeZone('Europe/Vienna');");
+            ZoneId zid = val.asTimeZone();
+            Assert.assertEquals("Europe/Vienna", zid.getId());
+        }
+
+        try (Context ctx = getJSContext()) {
+            Value val = ctx.eval(ID, "Temporal.TimeZone.from('+0645');");
+            ZoneId zid = val.asTimeZone();
+            Assert.assertTrue(zid instanceof ZoneOffset);
+            ZoneOffset zoff = (ZoneOffset) zid;
+            Assert.assertEquals(405 * 60, zoff.getTotalSeconds());
+        }
+    }
+
+    @Test
+    public void testZonedDateTime() {
+        try (Context ctx = getJSContext()) {
+            Value val = ctx.eval(ID, "new Temporal.ZonedDateTime(100_123_456_789n, Temporal.TimeZone.from('Europe/Vienna'));");
+            Instant inst = val.asInstant();
+            Assert.assertEquals(123_456_789L, inst.getNano());
+            Assert.assertEquals(100, inst.getEpochSecond());
+
+            LocalDate ld = val.asDate();
+            Assert.assertEquals(1970, ld.getYear());
+            Assert.assertEquals(Month.JANUARY, ld.getMonth());
+            Assert.assertEquals(1, ld.getDayOfYear());
+
+            LocalTime lt = val.asTime();
+            Assert.assertEquals(1, lt.getHour()); // offset of +1 due to timezone
+            Assert.assertEquals(1, lt.getMinute());
+            Assert.assertEquals(40, lt.getSecond());
+            Assert.assertEquals(123_456_789L, lt.getNano());
+
+            ZoneId zid = val.asTimeZone();
+            Assert.assertEquals("Europe/Vienna", zid.getId());
+        }
+    }
+
+    @Test
+    public void testDuration() {
+        try (Context ctx = getJSContext()) {
+            Value val = ctx.eval(ID, "Temporal.Duration.from('PT2H3M4.987654321S');");
+            Duration dur = val.asDuration();
+
+            long expectedSeconds = 2 * 60 * 60 + 3 * 60 + 4;
+            long expectedNanos = 987654321;
+            Assert.assertEquals(0, dur.toDays());
+            Assert.assertEquals(4, dur.toSecondsPart());
+            Assert.assertEquals(expectedSeconds, dur.toSeconds());
+            Assert.assertEquals(expectedNanos, dur.toNanosPart());
+            Assert.assertEquals(expectedSeconds * 1_000_000_000 + expectedNanos, dur.toNanos());
+
+            // invalid duration; java.time.Duration does not accept units larger or equals to DAY
+            val = ctx.eval(ID, "Temporal.Duration.from('P1Y');");
+            Assert.assertFalse(val.isDuration());
+            val = ctx.eval(ID, "Temporal.Duration.from('P2M');");
+            Assert.assertFalse(val.isDuration());
+            val = ctx.eval(ID, "Temporal.Duration.from('P3W');");
+            Assert.assertFalse(val.isDuration());
+            val = ctx.eval(ID, "Temporal.Duration.from('P4D');");
+            Assert.assertFalse(val.isDuration());
+        }
+    }
+}

graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/runtime/builtins/temporal/JSTemporalDurationObject.java

@@ -40,9 +40,18 @@
  */
 package com.oracle.truffle.js.runtime.builtins.temporal;
 
+import java.time.Duration;
+
+import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
+import com.oracle.truffle.api.interop.InteropLibrary;
+import com.oracle.truffle.api.interop.UnsupportedMessageException;
+import com.oracle.truffle.api.library.ExportLibrary;
+import com.oracle.truffle.api.library.ExportMessage;
 import com.oracle.truffle.api.object.Shape;
+import com.oracle.truffle.js.runtime.JSRuntime;
 import com.oracle.truffle.js.runtime.objects.JSNonProxyObject;
 
+@ExportLibrary(InteropLibrary.class)
 public class JSTemporalDurationObject extends JSNonProxyObject {
 
     private final double years;
@@ -110,4 +119,31 @@ public double getMicroseconds() {
     public double getNanoseconds() {
         return nanoseconds;
     }
+
+    @ExportMessage
+    final boolean isDuration() {
+        // note: java.time.Duration only considers DAYS, while JS Temporal also has W, M, Y.
+        // due to vague DAYS support in Java, we disallow conversion when any of D, W, M, Y is != 0.
+        return years == 0 && months == 0 && weeks == 0 && days == 0 && JSRuntime.doubleIsRepresentableAsLong(calcSeconds()) && JSRuntime.doubleIsRepresentableAsLong(calcNanoseconds());
+    }
+
+    @ExportMessage
+    @TruffleBoundary
+    final Duration asDuration() throws UnsupportedMessageException {
+        if (!isDuration()) {
+            throw UnsupportedMessageException.create();
+        }
+        double sec = calcSeconds();
+        double nanos = calcNanoseconds();
+        Duration dur = Duration.ofSeconds((long) sec, (long) nanos);
+        return dur;
+    }
+
+    private double calcNanoseconds() {
+        return nanoseconds + microseconds * 1_000 + milliseconds * 1_000_000;
+    }
+
+    private double calcSeconds() {
+        return seconds + minutes * 60 + hours * 60 * 60;
+    }
 }