Remove AST rewriting of @Builtin functions

Author: msimacek

graalpython/com.oracle.graal.python.test/testData/testFiles/RuntimeFileTests/functions.py

@@ -38,29 +38,29 @@
 # SOFTWARE.
 
 @__graalpython__.builtin
-def hasattr(obj, key):
+def hasattr(module, obj, key):
     default = object()
     return getattr(obj, key, default) is not default
 
 
 @__graalpython__.builtin
-def any(iterable):
+def any(module, iterable):
     for i in iterable:
         if i:
             return True
     return False
 
 
 @__graalpython__.builtin
-def all(iterable):
+def all(module, iterable):
     for i in iterable:
         if not i:
             return False
     return True
 
 
 @__graalpython__.builtin
-def filter(func, iterable):
+def filter(module, func, iterable):
     result = []
     predicate = func if func is not None else lambda a: a
     for i in iterable:
@@ -112,7 +112,7 @@ def __contains__(self, x):
 
 
 @__graalpython__.builtin
-def vars(*obj):
+def vars(module, *obj):
     """Return a dictionary of all the attributes currently bound in obj.  If
     called with no argument, return the variables bound in local scope."""
     if len(obj) == 0:
@@ -127,7 +127,7 @@ def vars(*obj):
 
 
 @__graalpython__.builtin
-def format(value, format_spec=''):
+def format(module, value, format_spec=''):
     """Return value.__format__(format_spec)
 
     format_spec defaults to the empty string.
@@ -137,7 +137,7 @@ def format(value, format_spec=''):
 
 
 @__graalpython__.builtin
-def sorted(iterable, key=None, reverse=False):
+def sorted(module, iterable, key=None, reverse=False):
     """Return a new list containing all items from the iterable in ascending order.
 
     A custom key function can be supplied to customize the sort order, and the

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

@@ -78,7 +78,6 @@
 import com.oracle.graal.python.builtins.objects.exception.OSErrorEnum;
 import com.oracle.graal.python.builtins.objects.exception.OSErrorEnum.ErrorAndMessagePair;
 import com.oracle.graal.python.builtins.objects.function.PFunction;
-import com.oracle.graal.python.builtins.objects.function.Signature;
 import com.oracle.graal.python.builtins.objects.generator.PGenerator;
 import com.oracle.graal.python.builtins.objects.list.PList;
 import com.oracle.graal.python.builtins.objects.method.PMethod;
@@ -88,10 +87,7 @@
 import com.oracle.graal.python.lib.PyObjectCallMethodObjArgs;
 import com.oracle.graal.python.lib.PyObjectTypeCheck;
 import com.oracle.graal.python.nodes.ErrorMessages;
-import com.oracle.graal.python.nodes.argument.ReadIndexedArgumentNode;
-import com.oracle.graal.python.nodes.argument.ReadVarArgsNode;
 import com.oracle.graal.python.nodes.builtins.FunctionNodes.GetCallTargetNode;
-import com.oracle.graal.python.nodes.builtins.FunctionNodes.GetSignatureNode;
 import com.oracle.graal.python.nodes.call.CallNode;
 import com.oracle.graal.python.nodes.classes.IsSubtypeNode;
 import com.oracle.graal.python.nodes.function.FunctionRootNode;
@@ -115,7 +111,6 @@
 import com.oracle.truffle.api.CallTarget;
 import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
-import com.oracle.truffle.api.RootCallTarget;
 import com.oracle.truffle.api.TruffleFile;
 import com.oracle.truffle.api.TruffleLanguage.Env;
 import com.oracle.truffle.api.TruffleLogger;
@@ -131,9 +126,7 @@
 import com.oracle.truffle.api.interop.UnsupportedMessageException;
 import com.oracle.truffle.api.library.CachedLibrary;
 import com.oracle.truffle.api.nodes.LanguageInfo;
-import com.oracle.truffle.api.nodes.Node;
 import com.oracle.truffle.api.nodes.NodeUtil;
-import com.oracle.truffle.api.nodes.NodeVisitor;
 import com.oracle.truffle.api.source.Source;
 import com.oracle.truffle.llvm.api.Toolchain;
 
@@ -448,56 +441,9 @@ public Object doIt(VirtualFrame frame, PFunction func) {
 
         @TruffleBoundary
         public synchronized PFunction convertToBuiltin(PFunction func) {
-            /*
-             * (tfel): To be compatible with CPython, builtin module functions must be bound to
-             * their respective builtin module. We ignore that builtin functions should really be
-             * builtin methods here - it does not hurt if they are normal methods. What does hurt,
-             * however, is if they are not bound, because then using these functions in class field
-             * won't work when they are called from an instance of that class due to the implicit
-             * currying with "self".
-             */
-            Signature signature = GetSignatureNode.getUncached().execute(func);
-            PFunction builtinFunc;
-            FunctionRootNode functionRootNode = (FunctionRootNode) CodeNodes.GetCodeRootNode.getUncached().execute(func.getCode());
-            if (signature.getParameterIds().length > 0 && signature.getParameterIds()[0].equals("self")) {
-                /*
-                 * If the first parameter is called self, we assume the function does explicitly
-                 * declare the module argument
-                 */
-                builtinFunc = func;
-                functionRootNode.setPythonInternal(true);
-            } else {
-                RootCallTarget callTarget = PythonLanguage.get(functionRootNode).createCachedCallTarget(
-                                r -> {
-                                    /*
-                                     * Otherwise, we create a new function with a signature that
-                                     * requires one extra argument in front. We actually modify the
-                                     * function's AST here, so the original PFunction cannot be used
-                                     * anymore (its signature won't agree with it's indexed
-                                     * parameter reads).
-                                     */
-                                    assert !functionRootNode.isPythonInternal() : "a function cannot be rewritten as builtin twice";
-                                    return functionRootNode.rewriteWithNewSignature(signature.createWithSelf(), new NodeVisitor() {
-
-                                        @Override
-                                        public boolean visit(Node node) {
-                                            if (node instanceof ReadVarArgsNode) {
-                                                node.replace(ReadVarArgsNode.create(((ReadVarArgsNode) node).isBuiltin()));
-                                            } else if (node instanceof ReadIndexedArgumentNode) {
-                                                node.replace(ReadIndexedArgumentNode.create(((ReadIndexedArgumentNode) node).getIndex() + 1));
-                                            }
-                                            return true;
-                                        }
-                                    }, x -> x);
-                                }, functionRootNode);
-
-                String name = func.getName();
-                builtinFunc = factory().createFunction(name, func.getEnclosingClassName(),
-                                factory().createCode(callTarget),
-                                func.getGlobals(), func.getDefaults(), func.getKwDefaults(), func.getClosure());
-            }
-
-            return builtinFunc;
+            FunctionRootNode rootNode = (FunctionRootNode) CodeNodes.GetCodeRootNode.getUncached().execute(func.getCode());
+            rootNode.setPythonInternal(true);
+            return func;
         }
     }
 

graalpython/lib-graalpython/__graalpython__.py

@@ -40,7 +40,7 @@
 import sys
 
 @builtin
-def import_current_as_named_module(name, owner_globals=None):
+def import_current_as_named_module(module, name, owner_globals=None):
     """
     load a builtin anonymous module which does not have a Truffle land builtin module counter part
 
@@ -62,7 +62,7 @@ def import_current_as_named_module(name, owner_globals=None):
 
 
 @builtin
-def lazy_attributes_from_delegate(delegate_name, attributes, owner_module, on_import_error):
+def lazy_attributes_from_delegate(module, delegate_name, attributes, owner_module, on_import_error):
     """
     used to lazily load attributes defined in another module via the __getattr__ mechanism.
     This will only cache the attributes in the caller module.
@@ -99,7 +99,7 @@ def __getattr__(attr):
 
 
 @builtin
-def auto_wrap_methods(delegate_name, delegate_attributes, owner_globals):
+def auto_wrap_methods(module, delegate_name, delegate_attributes, owner_globals):
     func_type = type(import_current_as_named_module)
 
     new_globals = dict(**owner_globals)
@@ -117,7 +117,7 @@ def auto_wrap_methods(delegate_name, delegate_attributes, owner_globals):
         if attr in delegate_attributes:
             def make_wrapper(attribute, method):
                 @__graalpython__.builtin
-                def wrapper(*args, **kwargs):
+                def wrapper(module, *args, **kwargs):
                     try:
                         return method(*args, **kwargs)
                     except NotImplementedError:
@@ -131,7 +131,7 @@ def wrapper(*args, **kwargs):
 
 
 @builtin
-def import_current_as_named_module_with_delegate(module_name, delegate_name, delegate_attributes=None,
+def import_current_as_named_module_with_delegate(module, module_name, delegate_name, delegate_attributes=None,
                                                  owner_globals=None, wrap_methods=True, on_import_error=None):
     owner_module = import_current_as_named_module(module_name, owner_globals=owner_globals)
     if wrap_methods and owner_globals:
@@ -142,7 +142,7 @@ def import_current_as_named_module_with_delegate(module_name, delegate_name, del
 
 
 @builtin
-def build_java_class(ns, name, base):
+def build_java_class(module, ns, name, base):
     ns['__super__'] = None  # place where store the original java class when instance is created
     ExtenderClass = type("PythonJavaExtenderClass", (object, ), ns)
     HostAdapter = __graalpython__.extend(base)

graalpython/lib-graalpython/_sre.py

@@ -587,32 +587,32 @@ def compile(pattern, flags, code, groups, groupindex, indexgroup):
 
 
 @__graalpython__.builtin
-def getcodesize(*args, **kwargs):
+def getcodesize(module, *args, **kwargs):
     raise NotImplementedError("_sre.getcodesize is not yet implemented")
 
 
 @__graalpython__.builtin
-def getlower(char_ord, flags):
+def getlower(module, char_ord, flags):
     import _cpython_sre
     return _cpython_sre.getlower(char_ord, flags)
 
 
 @__graalpython__.builtin
-def unicode_iscased(codepoint):
+def unicode_iscased(module, codepoint):
     ch = chr(codepoint)
     return ch != ch.lower() or ch != ch.upper()
 
 
 @__graalpython__.builtin
-def unicode_tolower(codepoint):
+def unicode_tolower(module, codepoint):
     return ord(chr(codepoint).lower())
 
 
 @__graalpython__.builtin
-def ascii_iscased(codepoint):
+def ascii_iscased(module, codepoint):
     return codepoint < 128 and chr(codepoint).isalpha()
 
 
 @__graalpython__.builtin
-def ascii_tolower(codepoint):
+def ascii_tolower(module, codepoint):
     return ord(chr(codepoint).lower()) if codepoint < 128 else codepoint

graalpython/lib-graalpython/builtins.py

@@ -56,7 +56,7 @@ def _f(): pass
 
 
 @__graalpython__.builtin
-def vars(*obj):
+def vars(module, *obj):
     """Return a dictionary of all the attributes currently bound in obj.  If
     called with no argument, return the variables bound in local scope."""
     if len(obj) == 0:
@@ -71,7 +71,7 @@ def vars(*obj):
 
 
 @__graalpython__.builtin
-def input(prompt=None):
+def input(module, prompt=None):
     import sys
     if(not hasattr(sys, "stdin")):
         raise RuntimeError('input(): lost sys.stdin')