Introduce built-in argument clinic conversion for double

Author: fangerer

graalpython/com.oracle.graal.python.annotations/src/com/oracle/graal/python/annotations/ArgumentClinic.java

@@ -135,5 +135,10 @@ enum ClinicConversion {
          * Corresponds to CPython's {@code Py_buffer} converter.
          */
         Buffer,
+        /**
+         * Corresponds to CPython's {@code double} converter. Supports {@link #defaultValue()}, and
+         * {@link #useDefaultForNone()}.
+         */
+        Double,
     }
 }

graalpython/com.oracle.graal.python.processor/src/com/oracle/graal/python/processor/ConverterFactory.java

@@ -96,6 +96,7 @@ public enum Param {
     private static ConverterFactory BuiltinIndex;
     private static ConverterFactory BuiltinSliceIndex;
     private static ConverterFactory BuiltinNone;
+    private static ConverterFactory BuiltinDouble;
 
     public final String fullClassName;
     public final String className;
@@ -121,6 +122,8 @@ public static ConverterFactory getBuiltin(ArgumentClinic annotation) {
                 return annotation.defaultValue().isEmpty() ? BuiltinString : BuiltinStringWithDefaultValue;
             case Int:
                 return BuiltinInt;
+            case Double:
+                return BuiltinDouble;
             case CodePoint:
                 return BuiltinCodePoint;
             case Buffer:
@@ -197,6 +200,7 @@ public static void initBuiltins(Elements elementUtils) throws ProcessingError {
         BuiltinString = forBuiltin(elementUtils, "JavaStringConverterNode");
         BuiltinStringWithDefaultValue = forBuiltin(elementUtils, "JavaStringConverterWithDefaultValueNode");
         BuiltinInt = forBuiltin(elementUtils, "JavaIntConversionNode");
+        BuiltinDouble = forBuiltin(elementUtils, "JavaDoubleConversionNode");
         BuiltinCodePoint = forBuiltin(elementUtils, "CodePointConversionNode");
         BuiltinBuffer = forBuiltin(elementUtils, "BufferConversionNode");
         BuiltinIndex = forBuiltin(elementUtils, "IndexConversionNode");

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/function/builtins/clinic/JavaDoubleConversionNode.java

@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2020, 2020, 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.graal.python.nodes.function.builtins.clinic;
+
+import com.oracle.graal.python.annotations.ArgumentClinic.PrimitiveType;
+import com.oracle.graal.python.annotations.ClinicConverterFactory;
+import com.oracle.graal.python.annotations.ClinicConverterFactory.DefaultValue;
+import com.oracle.graal.python.annotations.ClinicConverterFactory.UseDefaultForNone;
+import com.oracle.graal.python.builtins.objects.PNone;
+import com.oracle.graal.python.builtins.objects.floats.PFloat;
+import com.oracle.graal.python.builtins.objects.function.PArguments;
+import com.oracle.graal.python.builtins.objects.object.PythonObjectLibrary;
+import com.oracle.truffle.api.dsl.Specialization;
+import com.oracle.truffle.api.frame.VirtualFrame;
+import com.oracle.truffle.api.library.CachedLibrary;
+
+public abstract class JavaDoubleConversionNode extends ArgumentCastNode {
+
+    private final double defaultValue;
+    private final boolean useDefaultForNone;
+
+    protected JavaDoubleConversionNode(double defaultValue, boolean useDefaultForNone) {
+        this.defaultValue = defaultValue;
+        this.useDefaultForNone = useDefaultForNone;
+    }
+
+    @Specialization(guards = {"!useDefaultForNone", "isNoValue(none)"})
+    double doNoValue(@SuppressWarnings("unused") PNone none) {
+        return defaultValue;
+    }
+
+    @Specialization(guards = "useDefaultForNone")
+    double doNoValueAndNone(@SuppressWarnings("unused") PNone none) {
+        return defaultValue;
+    }
+
+    @Specialization
+    static double doDouble(double d) {
+        return d;
+    }
+
+    @Specialization
+    static double doPFloat(PFloat l) {
+        return l.getValue();
+    }
+
+    @Specialization(guards = "!isHandledPNone(value)", limit = "3")
+    double doOthers(VirtualFrame frame, Object value,
+                    @CachedLibrary("value") PythonObjectLibrary lib) {
+        return lib.asJavaDoubleWithState(value, PArguments.getThreadState(frame));
+    }
+
+    @ClinicConverterFactory(shortCircuitPrimitive = PrimitiveType.Double)
+    public static JavaDoubleConversionNode create(@DefaultValue double defaultValue, @UseDefaultForNone boolean useDefaultForNone) {
+        //return JavaIntConversionNodeGen.create(defaultValue, useDefaultForNone);
+        return null;
+    }
+
+    protected boolean isHandledPNone(Object value) {
+        return isHandledPNone(useDefaultForNone, value);
+    }
+
+}