[GR-27405] Mangle private attribute name in parser.

PullRequest: graalpython/1418

Author: ppisl

graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/debug/PythonDebugTest.java

@@ -385,19 +385,19 @@ public void testGettersSetters() throws Throwable {
                 assertTrue(x.hasWriteSideEffects());
                 assertTrue(x.isReadable());
                 assertTrue(x.isWritable());
-                assertEquals(0, p.getProperty("__nx").asInt());
+                assertEquals(0, p.getProperty("_P__nx").asInt());
                 assertEquals("None", x.toDisplayString());
-                assertEquals(1, p.getProperty("__nx").asInt());
+                assertEquals(1, p.getProperty("_P__nx").asInt());
                 x.set(42);
-                assertEquals(2, p.getProperty("__nx").asInt());
+                assertEquals(2, p.getProperty("_P__nx").asInt());
                 assertEquals("42", x.toDisplayString());
-                assertEquals(3, p.getProperty("__nx").asInt());
+                assertEquals(3, p.getProperty("_P__nx").asInt());
                 DebugValue y = p.getProperty("y");
                 assertTrue(y.hasReadSideEffects());
                 assertFalse(y.hasWriteSideEffects());
                 assertTrue(y.isReadable());
                 assertTrue(y.isWritable());
-                DebugValue ny = p.getProperty("__ny");
+                DebugValue ny = p.getProperty("_P__ny");
                 assertEquals(0, ny.asInt());
                 y.set(24);
                 assertEquals("24", y.toDisplayString());

graalpython/com.oracle.graal.python.test/src/tests/__mangled_module.py

@@ -0,0 +1,44 @@
+# Copyright (c) 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.
+
+def public_method():
+    print("I'm public")
+
+def __private_method():
+    print("I'm private")

graalpython/com.oracle.graal.python.test/src/tests/test_parser.py

@@ -246,3 +246,277 @@ def test_invalid_return_statement():
     assert_raise_syntax_error("class A: return 10\n", "'return' outside function")
 
 
+def test_mangled_class_property():
+    class P:
+        __property = 1
+        def get_property(self):
+            return self.__property
+        def get_mangled_property(self):
+            return self._P__property
+
+    p = P()
+    assert P._P__property == 1
+    assert "_P__property" in dir(P)
+    assert "__property" not in dir(P)
+    assert p._P__property == 1
+    assert "_P__property" in dir(p)
+    assert "__property" not in dir(p)
+    assert p.get_property() == 1
+    assert p.get_mangled_property() == 1
+
+    try:
+        print(P.__property)
+    except AttributeError as ae:
+        pass
+    else:
+        assert False, "AttributeError was not raised"
+
+    try:
+        print(p.__property)
+    except AttributeError as ae:
+        pass
+    else:
+        assert False, "AttributeError was not raised"
+
+    class B:
+        __ = 2
+
+    b = B()
+    assert B.__ == 2
+    assert "__" in dir(B)
+    assert b.__ == 2
+    assert "__" in dir(b)
+
+    class C:
+        ___ = 3
+
+    c = C()
+    assert C.___ == 3
+    assert "___" in dir(C)
+    assert c.___ == 3
+    assert "___" in dir(c)
+
+    class D:
+        _____ = 4
+
+    d = D()
+    assert D._____ == 4
+    assert "_____" in dir(D)
+    assert d._____ == 4
+    assert "_____" in dir(d)
+
+    class E:
+        def __init__(self, value):
+            self.__value = value
+        def getValue(self):
+            return self.__value
+
+    e = E(5)
+    assert e.getValue() == 5
+    assert e._E__value == 5
+    assert "_E__value" in dir(e)
+    assert "__value" not in dir(e) 
+
+    class F:
+        def __init__(self, value):
+            self.__a = value
+        def get(self):
+            return self.__a
+     
+    f = F(5)
+    assert "_F__a" in dir(f)
+    assert "__a" not in dir(f)
+     
+def test_underscore_class_name():
+    class _:
+        __a = 1
+    
+    assert _.__a == 1
+    assert "__a" in dir(_)
+    
+
+def test_mangled_class_method():
+    class A:
+        ___sound = "hello"
+        def __hello(self):
+            return self.___sound
+        def hello(self):
+            return self.__hello()
+
+    a = A()
+    assert "_A__hello" in dir(A)
+    assert "__hello" not in dir(A)
+    assert a.hello() == 'hello'
+    
+    try:
+        print(A.__hello)
+    except AttributeError as ae:
+        pass
+    else:
+        assert False, "AttributeError was not raised"
+
+    try:
+        print(a.__hello)
+    except AttributeError as ae:
+        pass
+    else:
+        assert False, "AttributeError was not raised"
+
+def test_mangled_private_class():
+    class __P:
+        __property = 1
+    
+    p = __P()
+    assert __P._P__property == 1
+    assert "_P__property" in dir(__P)
+    assert "__property" not in dir(__P)
+    assert p._P__property == 1
+    assert "_P__property" in dir(p)
+    assert "__property" not in dir(p)
+
+    class __:
+        __property = 2
+
+    p = __()
+    assert __.__property == 2
+    assert "__property" in dir(__)
+    assert p.__property == 2
+    assert "__property" in dir(p)
+   
+
+    class _____Testik__:
+        __property = 3
+
+    p = _____Testik__()
+    assert _____Testik__._Testik____property == 3
+    assert "_Testik____property" in dir(_____Testik__)
+    assert "__property" not in dir(_____Testik__)
+    assert p._Testik____property == 3
+    assert "_Testik____property" in dir(p)
+    assert "__property" not in dir(p)
+
+def test_mangled_import():
+    class X:
+        def fn(self):
+            import __mangled_module
+
+    assert '_X__mangled_module' in X.fn.__code__.co_varnames
+    assert '__mangled_module' not in X.fn.__code__.co_varnames
+    
+
+def test_mangled_params():
+    def xf(__param):
+        return __param
+    assert '__param' in xf.__code__.co_varnames
+    assert xf(10) == 10
+
+    class X:
+        def m1(self, __param):
+            return __param
+        def m2(self, *__arg):
+            return __arg
+        def m3(self, **__kw):
+            return __kw
+        
+
+    assert '_X__param' in X.m1.__code__.co_varnames
+    assert '__param' not in X.m1.__code__.co_varnames
+    assert X().m1(11) == 11
+
+    assert '_X__arg' in X.m2.__code__.co_varnames
+    assert '__arg' not in X.m2.__code__.co_varnames
+    assert X().m2(1, 2, 3) == (1,2,3)
+    
+    assert '_X__kw' in X.m3.__code__.co_varnames
+    assert '__kw' not in X.m3.__code__.co_varnames
+    assert X().m3(a = 1, b = 2) == {'a':1, 'b':2}
+
+def test_mangled_local_vars():
+    class L:
+        def fn(self, i):
+            __result = 0
+            for __index in range (1, i + 1):
+                __result += __index
+            return __result
+
+    assert '_L__result' in L.fn.__code__.co_varnames
+    assert '__result' not in L.fn.__code__.co_varnames
+    assert '_L__index' in L.fn.__code__.co_varnames
+    assert '__index' not in L.fn.__code__.co_varnames
+    assert L().fn(5) == 15
+
+
+def test_mangled_inner_function():
+    def find_code_object(code_object, name):
+        import types
+        for object in code_object.co_consts:
+            if type(object) == types.CodeType and object.co_name == name:
+                return object
+
+    class L:
+        def fn(self, i):
+            def __help(__i):
+                __result = 0
+                for __index in range (1, __i + 1):
+                    __result += __index
+                return __result
+            return __help(i)
+
+    assert '_L__help' in L.fn.__code__.co_varnames
+    assert '__help' not in L.fn.__code__.co_varnames
+
+    # CPython has stored as name of the code object the non mangle name. The question is, if this is right. 
+    co = find_code_object(L.fn.__code__, '__help')
+    if co is None:
+        co = find_code_object(L.fn.__code__, '_L__help')
+    assert co is not None
+    assert '_L__result' in co.co_varnames
+    assert '__result' not in co.co_varnames
+    assert '_L__index' in co.co_varnames
+    assert '__index' not in co.co_varnames
+    assert L().fn(5) == 15
+    
+
+def test_mangled_default_value_param():
+    class D:
+        def fn(self, __default = 5):
+            return __default
+
+    assert D().fn(_D__default = 11) == 11
+
+    try:
+        D().fn(__default = 11)
+    except TypeError as ae:
+        pass
+    else:
+        assert False, "TypeError was not raised"
+
+def test_method_decorator():
+    class S:
+        def __init__(self, value):
+            self.value = value
+        @property
+        def __ser(self):
+            return self.value
+        @__ser.setter
+        def __ser(self, value):
+            self.value = value
+
+    s = S(10)
+    assert s.value == 10
+    assert s._S__ser == 10
+    assert '_S__ser' in dir(S)
+    assert '_S__ser' in dir(s)
+    assert '__ser' not in dir(S)
+    assert '__ser' not in dir(s)
+
+    s.value = 11
+    assert s._S__ser == 11
+
+    s._S__ser = 12
+    assert s.value == 12
+
+    s.__ser = 13
+    assert s.value == 12
+    assert s.__ser == 13
+    assert s._S__ser == 12

graalpython/com.oracle.graal.python.test/testData/goldenFiles/GeneratorAndCompForTests/class01.tast

@@ -86,7 +86,7 @@ ModuleRootNode Name: <module 'class01'> SourceSection: [0,192]`class OrderedDict
                                           Frame: [1,root,Illegal]
                                         GetAttributeNodeGen SourceSection: [68,79]`self.__root`
                                           GetFixedAttributeNodeGen SourceSection: None
-                                            Key: __root
+                                            Key: _OrderedDict__root
                                             CachedDispatchFirst SourceSection: None
                                             LookupAndCallBinaryNodeGen SourceSection: None
                                               Op: __getattribute__

graalpython/com.oracle.graal.python.test/testData/testFiles/RuntimeFileTests/_collections_abc.scope

@@ -105,7 +105,7 @@ Scope: []
             FreeVars: Empty
     Scope: MutableMapping
         Kind: Class
-        FrameDescriptor: [__setitem__, pop, __marker, setdefault, clear, update, __slots__, popitem, __delitem__]
+        FrameDescriptor: [__setitem__, pop, _MutableMapping__marker, setdefault, clear, update, __slots__, popitem, __delitem__]
         CellVars: Empty
         FreeVars: Empty
         Scope: setdefault

graalpython/com.oracle.graal.python.test/testData/testFiles/RuntimeFileTests/_collections_abc.tast

@@ -9033,7 +9033,7 @@ ModuleRootNode Name: <module '_collections_abc'> SourceSection: [0,26444]`# Copy
               CelVars: None
               FreeVars: None
               NeedsCellFrame: False
-              FrameDescriptor: 9 slots [__slots__, __setitem__, __delitem__, __marker, pop, popitem, clear, update, setdefault]
+              FrameDescriptor: 9 slots [__slots__, __setitem__, __delitem__, _MutableMapping__marker, pop, popitem, clear, update, setdefault]
               ExecutionSlots:
                 FreeVarsSlots: None
                 CellVarsSlots: None
@@ -9220,7 +9220,7 @@ ModuleRootNode Name: <module '_collections_abc'> SourceSection: [0,26444]`# Copy
                                     Index: 0
                                 StringLiteralNode SourceSection: None
                               ReadGlobalOrBuiltinNodeGen SourceSection: None
-                                Identifier: __marker
+                                Identifier: _MutableMapping__marker
                                 ReadAttributeFromObjectNotTypeNodeGen SourceSection: None
                           KwArguments: None
                           Documentation: StringLiteralNode: `D.pop(k[,d]) -> v, r...`
@@ -9290,7 +9290,7 @@ ModuleRootNode Name: <module '_collections_abc'> SourceSection: [0,26444]`# Copy
                                                     ReadVariableFromFrameNodeGen SourceSection: None
                                                   GetAttributeNodeGen SourceSection: [20511,20524]`self.__marker`
                                                     GetFixedAttributeNodeGen SourceSection: None
-                                                      Key: __marker
+                                                      Key: _MutableMapping__marker
                                                       CachedDispatchFirst SourceSection: None
                                                       LookupAndCallBinaryNodeGen SourceSection: None
                                                         Op: __getattribute__