Hide internal methods implemented in python from python stack

Author: msimacek

graalpython/com.oracle.graal.python.test/src/tests/unittest_tags/test_traceback.txt

@@ -27,6 +27,7 @@
 *graalpython.lib-python.3.test.test_traceback.TestStack.test_extract_stack_limit
 *graalpython.lib-python.3.test.test_traceback.TestStack.test_extract_stack_lookup_lines
 *graalpython.lib-python.3.test.test_traceback.TestStack.test_extract_stackup_deferred_lookup_lines
+*graalpython.lib-python.3.test.test_traceback.TestStack.test_format_locals
 *graalpython.lib-python.3.test.test_traceback.TestStack.test_format_smoke
 *graalpython.lib-python.3.test.test_traceback.TestStack.test_from_list
 *graalpython.lib-python.3.test.test_traceback.TestStack.test_from_list_edited_stack

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

@@ -389,6 +389,9 @@ public synchronized PFunction convertToBuiltin(PFunction func) {
              */
             Signature signature = func.getSignature();
             PFunction builtinFunc;
+            FunctionRootNode functionRootNode = (FunctionRootNode) func.getFunctionRootNode();
+            assert !functionRootNode.isPythonInternal() : "a function cannot be annotated as builtin twice";
+            functionRootNode.setPythonInternal(true);
             if (signature.getParameterIds().length > 0 && signature.getParameterIds()[0].equals("self")) {
                 /*
                  * If the first parameter is called self, we assume the function does explicitly
@@ -402,9 +405,6 @@ public synchronized PFunction convertToBuiltin(PFunction func) {
                  * PFunction cannot be used anymore (its signature won't agree with it's indexed
                  * parameter reads).
                  */
-                FunctionRootNode functionRootNode = (FunctionRootNode) func.getFunctionRootNode();
-                assert !functionRootNode.isRewritten() : "a function cannot be annotated as builtin twice";
-
                 functionRootNode = functionRootNode.rewriteWithNewSignature(signature.createWithSelf(), new NodeVisitor() {
 
                     public boolean visit(Node node) {
@@ -428,6 +428,17 @@ public boolean visit(Node node) {
         }
     }
 
+    @Builtin(name = "builtin_method", minNumOfPositionalArgs = 1)
+    @GenerateNodeFactory
+    public abstract static class BuiltinMethodNode extends PythonUnaryBuiltinNode {
+        @Specialization
+        public Object doIt(PFunction func) {
+            FunctionRootNode functionRootNode = (FunctionRootNode) func.getFunctionRootNode();
+            functionRootNode.setPythonInternal(true);
+            return func;
+        }
+    }
+
     @Builtin(name = "get_toolchain_path", minNumOfPositionalArgs = 1)
     @TypeSystemReference(PythonArithmeticTypes.class)
     @GenerateNodeFactory

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/function/FunctionRootNode.java

@@ -70,7 +70,7 @@ public class FunctionRootNode extends PClosureFunctionRootNode {
     @Child private CalleeContext calleeContext = CalleeContext.create();
 
     private final ExpressionNode uninitializedBody;
-    private final boolean isRewritten;
+    private boolean isPythonInternal;
 
     public FunctionRootNode(PythonLanguage language, SourceSection sourceSection, String functionName, boolean isGenerator, boolean isRewritten, FrameDescriptor frameDescriptor,
                     ExpressionNode uninitializedBody, ExecutionCellSlots executionCellSlots, Signature signature) {
@@ -85,7 +85,7 @@ public FunctionRootNode(PythonLanguage language, SourceSection sourceSection, St
         // "uninitializedBody" is never modified or executed
         this.uninitializedBody = uninitializedBody;
         this.generatorFrameProfile = isGenerator ? ValueProfile.createClassProfile() : null;
-        this.isRewritten = isRewritten;
+        this.isPythonInternal = isRewritten;
     }
 
     /**
@@ -99,7 +99,7 @@ private FunctionRootNode(FunctionRootNode other) {
         this.functionName = other.functionName;
         this.isGenerator = other.isGenerator;
         this.generatorFrameProfile = other.isGenerator ? ValueProfile.createClassProfile() : null;
-        this.isRewritten = other.isRewritten;
+        this.isPythonInternal = other.isPythonInternal;
         this.uninitializedBody = other.uninitializedBody;
     }
 
@@ -110,7 +110,7 @@ protected boolean isCloneUninitializedSupported() {
 
     @Override
     protected RootNode cloneUninitialized() {
-        return new FunctionRootNode(PythonLanguage.getCurrent(), getSourceSection(), functionName, isGenerator, isRewritten, getFrameDescriptor(), uninitializedBody, executionCellSlots,
+        return new FunctionRootNode(PythonLanguage.getCurrent(), getSourceSection(), functionName, isGenerator, isPythonInternal, getFrameDescriptor(), uninitializedBody, executionCellSlots,
                         getSignature());
     }
 
@@ -206,18 +206,18 @@ public boolean isInternal() {
         return sourceSection != null && sourceSection.getSource().isInternal();
     }
 
-    public boolean isRewritten() {
-        return isRewritten;
-    }
-
     @Override
     public void initializeFrame(VirtualFrame frame) {
         initClosureAndCellVars(frame);
     }
 
     @Override
     public boolean isPythonInternal() {
-        return isRewritten;
+        return isPythonInternal;
+    }
+
+    public void setPythonInternal(boolean pythonInternal) {
+        isPythonInternal = pythonInternal;
     }
 
     public ExecutionCellSlots getExecutionCellSlots() {

graalpython/lib-graalpython/_collections.py

@@ -33,6 +33,7 @@
 class Block(object):
     __slots__ = ('leftlink', 'rightlink', 'data')
 
+    @__graalpython__.builtin_method
     def __init__(self, leftlink, rightlink):
         self.leftlink = leftlink
         self.rightlink = rightlink
@@ -68,6 +69,7 @@ def _next_or_none(_iter):
 
 
 class deque(object):
+    @__graalpython__.builtin_method
     def __init__(self, iterable=None, maxlen=None):
         if maxlen is None:
             self._maxlen = sys.maxsize
@@ -90,6 +92,7 @@ def __init__(self, iterable=None, maxlen=None):
             self.extend(iterable)
 
     def synchronized(fun):
+        @__graalpython__.builtin_method
         def fun_synchronized(self, *args):
             with self._mutex:
                 return fun(self, *args)
@@ -121,14 +124,17 @@ def pop(self):
         self._modified()
         return obj
 
+    @__graalpython__.builtin_method
     def _modified(self):
         self._lock = None
 
+    @__graalpython__.builtin_method
     def _getlock(self):
         if self._lock is None:
             self._lock = Lock()
         return self._lock
 
+    @__graalpython__.builtin_method
     def _checklock(self, lock):
         if lock is not self._lock:
             raise RuntimeError("deque mutated during iteration")
@@ -225,23 +231,29 @@ def extend(self, iterable):
                 break
             self.append(obj)
 
+    @__graalpython__.builtin_method
     def __iadd__(self, other):
         return _add(self, other)
 
+    @__graalpython__.builtin_method
     def __add__(self, other):
         if not isinstance(other, deque):
             raise TypeError("can only concatenate deque (not '%s') to deque" % (type(other)))
         return _add(deque(self, maxlen=self.maxlen), other)
 
+    @__graalpython__.builtin_method
     def __imul__(self, times):
         return _mul(self, times)
 
+    @__graalpython__.builtin_method
     def __mul__(self, times):
         return _mul(deque(self, maxlen=self.maxlen), times)
 
+    @__graalpython__.builtin_method
     def __rmul__(self, times):
         return _mul(deque(self, maxlen=self.maxlen), times)
 
+    @__graalpython__.builtin_method
     def __hash__(self):
         raise TypeError("unhashable type: '{}'".format(type(self).__name__))
 
@@ -343,16 +355,20 @@ def rotate(self, n=1):
             self.append(self.popleft())
             i -= 1
 
+    @__graalpython__.builtin_method
     def __iter__(self):
         return _DequeIter(self)
 
+    @__graalpython__.builtin_method
     def __reversed__(self):
         """Return a reverse iterator over the deque."""
         return _DequeRevIter(self)
 
+    @__graalpython__.builtin_method
     def __len__(self):
         return self.len
 
+    @__graalpython__.builtin_method
     def __repr__(self):
         # TODO: this does not handle infinite repr recursive calls ... (GR-10763)
         try:
@@ -405,6 +421,7 @@ def __compare__(self, other, op):
                     return x1 >= x2
                 assert False, "bad value for op"
 
+    @__graalpython__.builtin_method
     def __contains__(self, v):
         lock = self._getlock()
         n = self.len
@@ -427,13 +444,15 @@ def __contains__(self, v):
 
         return False
 
+    @__graalpython__.builtin_method
     def _norm_index(self, idx, force_index_to_zero=True):
         if idx < 0:
             idx += self.len
             if idx < 0 and force_index_to_zero:
                 idx = 0
         return idx
 
+    @__graalpython__.builtin_method
     def _check_index(self, idx):
         if idx < 0 or idx >= self.len:
             raise IndexError("deque index out of range")
@@ -482,24 +501,31 @@ def index(self, v, start=0, stop=None):
 
         raise ValueError("%s is not in deque" % v)
 
+    @__graalpython__.builtin_method
     def __lt__(self, other):
         return self.__compare__(other, 'lt')
 
+    @__graalpython__.builtin_method
     def __le__(self, other):
         return self.__compare__(other, 'le')
 
+    @__graalpython__.builtin_method
     def __eq__(self, other):
         return self.__compare__(other, 'eq')
 
+    @__graalpython__.builtin_method
     def __ne__(self, other):
         return self.__compare__(other, 'ne')
 
+    @__graalpython__.builtin_method
     def __gt__(self, other):
         return self.__compare__(other, 'gt')
 
+    @__graalpython__.builtin_method
     def __ge__(self, other):
         return self.__compare__(other, 'ge')
 
+    @__graalpython__.builtin_method
     def _locate(self, i):
         if i < (self.len >> 1):
             i += self.leftindex
@@ -517,25 +543,29 @@ def _locate(self, i):
         assert i >= 0
         return b, i
 
+    @__graalpython__.builtin_method
     def delitem(self, i):
         # delitem() implemented in terms of rotate for simplicity and
         # reasonable performance near the end points.
         self.rotate(-i)
         self.popleft()
         self.rotate(i)
 
+    @__graalpython__.builtin_method
     def __getitem__(self, idx):
         idx = self._norm_index(idx)
         self._check_index(idx)
         b, i = self._locate(idx)
         return b.data[i]
 
+    @__graalpython__.builtin_method
     def __setitem__(self, idx, value):
         idx = self._norm_index(idx, force_index_to_zero=False)
         self._check_index(idx)
         b, i = self._locate(idx)
         b.data[i] = value
 
+    @__graalpython__.builtin_method
     def __delitem__(self, idx):
         idx = self._norm_index(idx, force_index_to_zero=False)
         self._check_index(idx)
@@ -549,9 +579,11 @@ def copy(self):
         else:
             return deque(self, self.maxlen)
 
+    @__graalpython__.builtin_method
     def __copy__(self):
         return self.copy()
 
+    @__graalpython__.builtin_method
     def __reduce__(self):
         """Return state information for pickling."""
         _type = type(self)
@@ -581,6 +613,7 @@ def maxlen(self):
 
 
 class _DequeIter(object):
+    @__graalpython__.builtin_method
     def __init__(self, dq):
         self._deque = dq
         self.block = dq.leftblock
@@ -589,12 +622,15 @@ def __init__(self, dq):
         self.lock = dq._getlock()
         assert self.index >= 0
 
+    @__graalpython__.builtin_method
     def __iter__(self):
         return self
 
+    @__graalpython__.builtin_method
     def __len__(self):
         return self.counter
 
+    @__graalpython__.builtin_method
     def __next__(self):
         if self.lock is not self._deque._lock:
             self.counter = 0
@@ -613,6 +649,7 @@ def __next__(self):
 
 
 class _DequeRevIter(object):
+    @__graalpython__.builtin_method
     def __init__(self, dq):
         self._deque = dq
         self.block = dq.rightblock
@@ -621,12 +658,15 @@ def __init__(self, dq):
         self.lock = dq._getlock()
         assert self.index >= 0
 
+    @__graalpython__.builtin_method
     def __iter__(self):
         return self
 
+    @__graalpython__.builtin_method
     def __len__(self):
         return self.counter
 
+    @__graalpython__.builtin_method
     def __next__(self):
         if self.lock is not self._deque._lock:
             self.counter = 0
@@ -645,22 +685,26 @@ def __next__(self):
 
 
 class defaultdict(dict):
+    @__graalpython__.builtin_method
     def __init__(self, default_factory=None, *args, **kwds):
         dict.__init__(self, *args, **kwds)
         if (default_factory is None or callable(default_factory)):
             self.default_factory = default_factory
         else:
             raise TypeError("first argument must be callable or None")
 
+    @__graalpython__.builtin_method
     def __missing__(self, key):
         if self.default_factory is None:
             raise KeyError(key)
         self[key] = value = self.default_factory()
         return value
 
+    @__graalpython__.builtin_method
     def __repr__(self):
         return "%s(%r, %s)" % (type(self).__name__, self.default_factory, dict.__repr__(self))
 
+    @__graalpython__.builtin_method
     def copy(self):
         cp = defaultdict(default_factory=self.default_factory)
         for k,v in self.items():

graalpython/lib-graalpython/array.py

@@ -45,5 +45,5 @@ def frombytes(self, bytesLike):
 def fromfile(self, f, n):
     self.frombytes(f.read(n))
 
-array.frombytes = frombytes
-array.fromfile = fromfile
+array.frombytes = __graalpython__.builtin_method(frombytes)
+array.fromfile = __graalpython__.builtin_method(fromfile)

graalpython/lib-graalpython/bytearray.py

@@ -46,5 +46,5 @@ def strip(self, what=None):
     return self.lstrip(what).rstrip(what)
 
 
-bytearray.strip = strip
+bytearray.strip = __graalpython__.builtin_method(strip)
 bytearray.rfind = bytes.rfind