add support for calling __getattr__ when __getattribute__ raises AttributeError

Author: cosminbasca

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

@@ -60,11 +60,37 @@ def set_dict_attr():
     assert_raises(AttributeError, set_dict_attr)
 
     class MyClass(object):
-        pass
+        def __init__(self):
+            self.a = 9
 
     m = MyClass()
-    assert m.__dict__ == {}
+    assert m.a == 9
+    assert m.__dict__ == {'a': 9}
+    assert m.a == 9
     m.__dict__ = {'a': 10}
     assert m.__dict__ == {'a': 10}
     assert m.a == 10
 
+    class MyOtherClass(object):
+        def __getattribute__(self, item):
+            return object.__getattribute__(self, item)
+
+        def __getattr__(self, item):
+            if item == "my_attr":
+                return 10
+            raise AttributeError
+
+    m1 = MyOtherClass()
+    print()
+
+    def get_non_existing_attr():
+        return m1.my_attr_2
+
+    assert_raises(AttributeError, get_non_existing_attr)
+    assert m1.my_attr == 10
+    assert "my_attr" not in m1.__dict__
+
+    m1.__dict__ = {'d': 10}
+    assert m1.my_attr == 10
+    assert "my_attr" not in m1.__dict__
+    assert m1.d == 10

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/attributes/GetAttributeNode.java

@@ -41,21 +41,29 @@
 package com.oracle.graal.python.nodes.attributes;
 
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__GETATTRIBUTE__;
+import static com.oracle.graal.python.nodes.SpecialMethodNames.__GETATTR__;
+import static com.oracle.graal.python.runtime.exception.PythonErrorType.AttributeError;
 
 import com.oracle.graal.python.nodes.call.special.LookupAndCallBinaryNode;
 import com.oracle.graal.python.nodes.expression.ExpressionNode;
 import com.oracle.graal.python.nodes.frame.ReadNode;
 import com.oracle.graal.python.nodes.statement.StatementNode;
+import com.oracle.graal.python.runtime.exception.PException;
+import com.oracle.truffle.api.CompilerDirectives;
+import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
 import com.oracle.truffle.api.dsl.NodeChild;
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.nodes.UnexpectedResultException;
+import com.oracle.truffle.api.profiles.ConditionProfile;
 
 @NodeChild(value = "object", type = ExpressionNode.class)
 public abstract class GetAttributeNode extends ExpressionNode implements ReadNode {
 
     private final String key;
 
     @Child LookupAndCallBinaryNode dispatchNode = LookupAndCallBinaryNode.create(__GETATTRIBUTE__);
+    @Child LookupAndCallBinaryNode dispatchGetAttr;
+    @CompilationFinal private ConditionProfile errorProfile = ConditionProfile.createBinaryProfile();
 
     protected GetAttributeNode(String key) {
         this.key = key;
@@ -77,16 +85,39 @@ public static GetAttributeNode create(String key, ExpressionNode object) {
 
     @Specialization(rewriteOn = UnexpectedResultException.class)
     protected int doItInt(Object object) throws UnexpectedResultException {
-        return dispatchNode.executeInt(object, key);
+        try {
+            return dispatchNode.executeInt(object, key);
+        } catch (PException pe) {
+            pe.expect(AttributeError, getCore(), errorProfile);
+            return getDispatchGetAttr().executeInt(object, key);
+        }
     }
 
     @Specialization(rewriteOn = UnexpectedResultException.class)
     protected boolean doItBoolean(Object object) throws UnexpectedResultException {
-        return dispatchNode.executeBool(object, key);
+        try {
+            return dispatchNode.executeBool(object, key);
+        } catch (PException pe) {
+            pe.expect(AttributeError, getCore(), errorProfile);
+            return getDispatchGetAttr().executeBool(object, key);
+        }
     }
 
     @Specialization(replaces = {"doItInt", "doItBoolean"})
     protected Object doIt(Object object) {
-        return dispatchNode.executeObject(object, key);
+        try {
+            return dispatchNode.executeObject(object, key);
+        } catch (PException pe) {
+            pe.expect(AttributeError, getCore(), errorProfile);
+            return getDispatchGetAttr().executeObject(object, key);
+        }
+    }
+
+    private LookupAndCallBinaryNode getDispatchGetAttr() {
+        if (dispatchGetAttr == null) {
+            CompilerDirectives.transferToInterpreterAndInvalidate();
+            dispatchGetAttr = insert(LookupAndCallBinaryNode.create(__GETATTR__));
+        }
+        return dispatchGetAttr;
     }
 }