Avoid using generic float() specialization when a more suitable one exists

Author: otethal

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/BuiltinConstructors.java

@@ -915,7 +915,7 @@ public Object reversed(VirtualFrame frame, Object cls, Object sequence,
     @Builtin(name = FLOAT, minNumOfPositionalArgs = 1, maxNumOfPositionalArgs = 2, constructsClass = PythonBuiltinClassType.PFloat)
     @GenerateNodeFactory
     @ReportPolymorphism
-    public abstract static class FloatNode extends PythonBuiltinNode {
+    public abstract static class FloatNode extends PythonBinaryBuiltinNode {
         @Child private BytesNodes.ToBytesNode toByteArrayNode;
         @Child private LookupAndCallUnaryNode callFloatNode;
         @Child private LookupAndCallUnaryNode callReprNode;
@@ -982,15 +982,6 @@ Object floatFromString(VirtualFrame frame, Object cls, String arg) {
             return factoryCreateFloat(cls, value);
         }
 
-        @Specialization(guards = "!isNativeClass(cls)")
-        Object floatFromBytes(VirtualFrame frame, Object cls, PIBytesLike arg) {
-            double value = convertBytesToDouble(frame, arg);
-            if (isPrimitiveFloat(cls)) {
-                return value;
-            }
-            return factoryCreateFloat(cls, value);
-        }
-
         private double convertBytesToDouble(VirtualFrame frame, PIBytesLike arg) {
             return convertStringToDouble(frame, createString(getByteArray(frame, arg)), arg);
         }
@@ -1101,16 +1092,13 @@ Object floatFromNone(Object cls, @SuppressWarnings("unused") PNone arg) {
             return factory().createFloat(cls, 0.0);
         }
 
-        @Specialization(guards = "isPrimitiveFloat(cls)")
+        static boolean isHandledType(Object o) {
+            return PGuards.canBeInteger(o) || PGuards.isDouble(o) || o instanceof String || PGuards.isPNone(o);
+        }
+
+        @Specialization(guards = {"isPrimitiveFloat(cls)", "!isHandledType(obj)"})
         double doubleFromObject(VirtualFrame frame, @SuppressWarnings("unused") Object cls, Object obj,
                         @CachedLibrary(limit = "1") PythonObjectLibrary lib) {
-
-            if (obj instanceof PNone) {
-                return 0.0;
-            }
-            if (obj instanceof String) {
-                return convertStringToDouble(frame, (String) obj, obj);
-            }
             // Follows logic from PyNumber_Float:
             // lib.asJavaDouble cannot be used here because it models PyFloat_AsDouble,
             // which ignores __float__ defined by float subclasses, whereas PyNumber_Float
@@ -1136,6 +1124,7 @@ Object floatFromNone(Object cls, @SuppressWarnings("unused") PNone arg) {
                 return lib.asJavaDouble(lib.asIndex(obj));
             }
             // Follows logic from PyFloat_FromString:
+            // These types are handled only if the object doesn't implement __float__/__index__
             if (obj instanceof PString) {
                 return convertStringToDouble(frame, ((PString) obj).getValue(), obj);
             } else if (obj instanceof PIBytesLike) {
@@ -1151,10 +1140,14 @@ Object floatFromNone(Object cls, @SuppressWarnings("unused") PNone arg) {
             throw raise(PythonBuiltinClassType.TypeError, ErrorMessages.ARG_MUST_BE_STRING_OR_NUMBER, "float()", obj);
         }
 
-        @Specialization(guards = "!isNativeClass(cls)")
+        @Specialization(guards = {"!isNativeClass(cls)", "!isPrimitiveFloat(cls)"})
         Object doPythonObject(VirtualFrame frame, Object cls, Object obj,
-                        @CachedLibrary(limit = "1") PythonObjectLibrary lib) {
-            return floatFromDouble(cls, doubleFromObject(frame, cls, obj, lib));
+                        @Cached FloatNode recursiveCallNode) {
+            Object doubleValue = recursiveCallNode.executeWith(frame, PythonBuiltinClassType.PFloat, obj);
+            if (!(doubleValue instanceof Double)) {
+                throw CompilerDirectives.shouldNotReachHere("float() returned non-primitive value");
+            }
+            return floatFromDouble(cls, (double) doubleValue);
         }
 
         // logic similar to float_subtype_new(PyTypeObject *type, PyObject *x) from CPython
@@ -1164,9 +1157,12 @@ Object doPythonObject(VirtualFrame frame, Object cls, Object obj,
         Object doPythonObject(VirtualFrame frame, PythonNativeClass cls, Object obj,
                         @Cached @SuppressWarnings("unused") IsSubtypeNode isSubtype,
                         @Cached CExtNodes.FloatSubtypeNew subtypeNew,
-                        @CachedLibrary(limit = "1") PythonObjectLibrary lib) {
-            double realFloat = doubleFromObject(frame, PythonBuiltinClassType.PFloat, obj, lib);
-            return subtypeNew.call(cls, realFloat);
+                        @Cached FloatNode recursiveCallNode) {
+            Object doubleValue = recursiveCallNode.executeWith(frame, PythonBuiltinClassType.PFloat, obj);
+            if (!(doubleValue instanceof Double)) {
+                throw CompilerDirectives.shouldNotReachHere("float() returned non-primitive value");
+            }
+            return subtypeNew.call(cls, (double) doubleValue);
         }
 
         @Fallback

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/PythonCextBuiltins.java

@@ -2654,7 +2654,7 @@ Object doGeneric(VirtualFrame frame, @SuppressWarnings("unused") Object module,
                         @Shared("asPythonObjectNode") @Cached AsPythonObjectNode asPythonObjectNode) {
             if (floatNode == null) {
                 CompilerDirectives.transferToInterpreterAndInvalidate();
-                floatNode = insert(BuiltinConstructorsFactory.FloatNodeFactory.create(null));
+                floatNode = insert(BuiltinConstructorsFactory.FloatNodeFactory.create());
             }
             return toNewRefNode.execute(floatNode.executeWith(frame, PythonBuiltinClassType.PFloat, asPythonObjectNode.execute(object)));
         }