Compiled understands hasattr on classes.

Author: braxtonmckee

typed_python/HeldClassType.cpp

@@ -243,6 +243,7 @@ RefTo* HeldClass::getRefToType() {
 
 void HeldClass::delAttribute(instance_ptr self, int memberIndex) const {
     Type* member_t = m_members[memberIndex].getType();
+
     if (checkInitializationFlag(self, memberIndex)) {
         member_t->destroy(eltPtr(self, memberIndex));
         clearInitializationFlag(self, memberIndex);
@@ -337,6 +338,8 @@ void HeldClass::copy_constructor(instance_ptr self, instance_ptr other) {
         if (checkInitializationFlag(other, k)) {
             member_t->copy_constructor(self+m_byte_offsets[k], other+m_byte_offsets[k]);
             setInitializationFlag(self, k);
+        } else {
+            clearInitializationFlag(self, k);
         }
     }
 }

typed_python/PyRefToInstance.cpp

@@ -129,10 +129,11 @@ int PyRefToInstance::tp_setattr_concrete(PyObject* attrName, PyObject* attrVal)
     }
 
     HeldClass* clsType = (HeldClass*)type()->getEltType();
+    instance_ptr heldClassBody = *(instance_ptr*)dataPtr();
 
-    int i = clsType->getMemberIndex(PyUnicode_AsUTF8(attrName));
+    int memberIndex = clsType->getMemberIndex(PyUnicode_AsUTF8(attrName));
 
-    if (i < 0) {
+    if (memberIndex < 0) {
         auto it = clsType->getClassMembers().find(PyUnicode_AsUTF8(attrName));
         if (it == clsType->getClassMembers().end()) {
             PyErr_Format(
@@ -150,23 +151,44 @@ int PyRefToInstance::tp_setattr_concrete(PyObject* attrName, PyObject* attrVal)
         return -1;
     }
 
-    Type* eltType = clsType->getMemberType(i);
+    if (!attrVal) {
+        if (clsType->getMemberIsNonempty(memberIndex)) {
+            PyErr_Format(
+                PyExc_AttributeError,
+                "Attribute '%S' cannot be deleted",
+                attrName
+            );
+            return -1;
+        }
 
-    Type* attrType = extractTypeFrom(attrVal->ob_type);
+        if (!clsType->checkInitializationFlag(heldClassBody, memberIndex)) {
+            PyErr_Format(
+                PyExc_AttributeError,
+                "Attribute '%S' is not initialized",
+                attrName
+            );
+            return -1;
+        }
 
-    instance_ptr heldClassBody = *(instance_ptr*)dataPtr();
+        clsType->delAttribute(heldClassBody, memberIndex);
+        return 0;
+    }
+
+    Type* eltType = clsType->getMemberType(memberIndex);
+
+    Type* attrType = extractTypeFrom(attrVal->ob_type);
 
     if (Type::typesEquivalent(eltType, attrType)) {
         PyInstance* item_w = (PyInstance*)attrVal;
 
-        clsType->setAttribute(heldClassBody, i, item_w->dataPtr());
+        clsType->setAttribute(heldClassBody, memberIndex, item_w->dataPtr());
 
         return 0;
     } else if (attrType && attrType->getTypeCategory() == Type::TypeCategory::catRefTo &&
             ((RefTo*)attrType)->getEltType() == eltType) {
         PyInstance* item_w = (PyInstance*)attrVal;
 
-        clsType->setAttribute(heldClassBody, i, *(instance_ptr*)item_w->dataPtr());
+        clsType->setAttribute(heldClassBody, memberIndex, *(instance_ptr*)item_w->dataPtr());
 
         return 0;
     } else {
@@ -182,7 +204,7 @@ int PyRefToInstance::tp_setattr_concrete(PyObject* attrName, PyObject* attrVal)
             return -1;
         }
 
-        clsType->setAttribute(heldClassBody, i, tempObj);
+        clsType->setAttribute(heldClassBody, memberIndex, tempObj);
 
         eltType->destroy(tempObj);
         tp_free(tempObj);

typed_python/__init__.py

@@ -95,3 +95,5 @@
 # when we're acquiring and releasing frequently.
 gilReleaseThreadLoop = threading.Thread(target=_types.gilReleaseThreadLoop, daemon=True)
 gilReleaseThreadLoop.start()
+
+_types.setGilReleaseThreadLoopSleepMicroseconds(500)

typed_python/compiler/function_conversion_context.py

@@ -2212,6 +2212,25 @@ def convert_iteration_expression(self, to_iterate, ast, variableSuffix, controlF
 
         self.assignToLocalVariable(iter_varname, iterator_object, variableStates)
 
+        if iterator_object.expr_type.has_intiter():
+            # execute the 'intiter' fastpath for iterators. Classes where iteration
+            # is simply enumerating a list of values indexed by an integer can
+            # be replaced with a simple loop, which downstream compilation steps
+            # can see through better. Eventually, we'd like to be able to pull apart
+            # everything we're doing with classes for optimization purposes,
+            # but at the moment, this is more expedient.
+            iter_varname = ".iterate_over." + str(ast.line_number) + variableSuffix
+
+            self.assignToLocalVariable(iter_varname, iterator_object, variableStates)
+
+            inner, innerReturns = self.convert_statement_list_ast(
+                list(rewriteIntiterForLoop(iter_varname, ast.target, ast.body, ast.orelse)),
+                variableStates,
+                controlFlowBlocks,
+            )
+
+            return context.finalize(inner, exceptionsTakeFrom=ast), innerReturns
+
         while True:
             # track the initial variable states
             initVariableStates = variableStates.clone()

typed_python/compiler/python_object_representation.py

@@ -57,6 +57,7 @@
 from typed_python.compiler.type_wrappers.deserialize_wrapper import DeserializeWrapper
 from typed_python.compiler.type_wrappers.time_wrapper import TimeWrapper
 from typed_python.compiler.type_wrappers.super_wrapper import SuperWrapper
+from typed_python.compiler.type_wrappers.hasattr_wrapper import HasattrWrapper
 from typed_python.compiler.type_wrappers.compiler_introspection_wrappers import (
     IsCompiledWrapper,
     TypeKnownToCompiler,
@@ -240,6 +241,9 @@ def pythonObjectRepresentation(context, f, owningGlobalScopeAndName=None):
     if isinstance(f, CompilableBuiltin):
         return TypedExpression(context, native_ast.nullExpr, f, False)
 
+    if f is hasattr:
+        return TypedExpression(context, native_ast.nullExpr, HasattrWrapper(), False)
+
     if f is len:
         return TypedExpression(context, native_ast.nullExpr, LenWrapper(), False)
 

typed_python/compiler/tests/class_compilation_test.py

@@ -2932,3 +2932,72 @@ def doIt():
 
         doIt()
         Entrypoint(doIt)()
+
+    def test_class_hasattr(self):
+        class C(Class):
+            x = Member(int)
+
+            def __init__(self):
+                del self.x
+
+            def __init__(self, x):  # noqa
+                self.x = x
+
+        @Entrypoint
+        def compiledHasattr(c):
+            return hasattr(c, 'x')
+
+        @Entrypoint
+        def compiledGenericHasattr(c, attr):
+            return hasattr(c, attr)
+
+        assert compiledGenericHasattr.resultTypeFor(C, str).typeRepresentation is bool
+
+        assert hasattr(C(x=1), 'x')
+        assert compiledHasattr(C(x=1))
+        assert compiledGenericHasattr(C(x=1), 'x')
+
+        assert not hasattr(C(), 'x')
+        assert not compiledHasattr(C())
+        assert not compiledGenericHasattr(C(), 'x')
+
+        @Entrypoint
+        def compiledDel():
+            c = C(x=1)
+            assert hasattr(c, 'x')
+            del c.x
+            assert not hasattr(c, 'x')
+
+        compiledDel()
+
+    def test_class_hasattr_perf(self):
+        class C(Class):
+            x = Member(float)
+
+        @Entrypoint
+        def loopWithoutHasattr(c):
+            res = 0.0
+            for _ in range(10000000):
+                res += c.x
+            return res
+
+        @Entrypoint
+        def loopWithHasattr(c):
+            res = 0.0
+            for _ in range(10000000):
+                if hasattr(c, 'x'):
+                    res += c.x
+            return res
+
+        loopWithHasattr(C())
+        loopWithoutHasattr(C())
+
+        t0 = time.time()
+        loopWithHasattr(C())
+        elapsedWith = time.time() - t0
+
+        t0 = time.time()
+        loopWithoutHasattr(C())
+        elapsedWithout = time.time() - t0
+
+        assert .6 < elapsedWithout / elapsedWith < 1.4

typed_python/compiler/tests/generators_test.py

@@ -165,10 +165,14 @@ def listCompSumUntyped(x):
 
     @flaky(max_runs=3, min_passes=1)
     def test_untyped_tuple_from_listcomp_perf(self):
+        import time
+
         def sum(iterable):
+            t0 = time.time()
             res = 0
             for s in iterable:
                 res += s
+            print("took ", time.time() - t0)
             return res
 
         @Entrypoint

typed_python/compiler/tests/held_class_compilation_test.py

@@ -432,3 +432,68 @@ def doIt():
 
         assert len(delType) >= 1
         assert delType[0] == C
+
+    def test_class_hasattr(self):
+        @Held
+        class C(Class):
+            x = Member(int)
+
+            def __init__(self):
+                assert hasattr(self, 'x')
+                del self.x
+                assert not hasattr(self, 'x')
+
+            def __init__(self, x):  # noqa
+                self.x = x
+
+        @Entrypoint
+        def compiledHasattr(c):
+            return hasattr(c, 'x')
+
+        assert hasattr(C(x=1), 'x')
+        assert compiledHasattr(C(x=1))
+
+        assert not hasattr(C(), 'x')
+        assert not compiledHasattr(C())
+
+        @Entrypoint
+        def compiledDel():
+            c = C(x=1)
+            assert hasattr(c, 'x')
+            del c.x
+            assert not hasattr(c, 'x')
+
+        compiledDel()
+
+    def test_class_hasattr_perf(self):
+        @Held
+        class C(Class):
+            x = Member(float)
+
+        @Entrypoint
+        def loopWithoutHasattr(c):
+            res = 0.0
+            for _ in range(10000000):
+                res += c.x
+            return res
+
+        @Entrypoint
+        def loopWithHasattr(c):
+            res = 0.0
+            for _ in range(10000000):
+                if hasattr(c, 'x'):
+                    res += c.x
+            return res
+
+        loopWithHasattr(C())
+        loopWithoutHasattr(C())
+
+        t0 = time.time()
+        loopWithHasattr(C())
+        elapsedWith = time.time() - t0
+
+        t0 = time.time()
+        loopWithoutHasattr(C())
+        elapsedWithout = time.time() - t0
+
+        assert .6 < elapsedWithout / elapsedWith < 1.4

typed_python/compiler/type_wrappers/class_wrapper.py

@@ -196,6 +196,20 @@ def __init__(self, t):
             )
         ).load()
 
+    def convert_hasattr(self, context, instance, attribute):
+        if attribute.constantValue is not None and attribute.constantValue in self.nameToIndex:
+            ix = self.nameToIndex[attribute.constantValue]
+
+            if self.fieldGuaranteedInitialized(ix):
+                return context.constant(True)
+
+            return context.pushPod(
+                bool,
+                self.isInitializedNativeExpr(instance, ix)
+            )
+
+        return super().convert_hasattr(context, instance, attribute)
+
     def fieldGuaranteedInitialized(self, ix):
         if self.classType.MemberNames[ix] not in self.typeRepresentation.ClassMembers:
             raise Exception(

typed_python/compiler/type_wrappers/hasattr_wrapper.py

@@ -0,0 +1,36 @@
+#   Copyright 2017-2023 typed_python Authors
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+import time
+
+
+from typed_python.compiler.type_wrappers.wrapper import Wrapper
+import typed_python.compiler.native_ast as native_ast
+
+
+class HasattrWrapper(Wrapper):
+    is_pod = True
+    is_empty = False
+    is_pass_by_ref = False
+
+    def __init__(self):
+        super().__init__(time.time)
+
+    def getNativeLayoutType(self):
+        return native_ast.Type.Void()
+
+    def convert_call(self, context, expr, args, kwargs):
+        if len(args) == 2 and len(kwargs) == 0:
+            return args[0].convert_hasattr(args[1])
+
+        return expr.toPyObj().convert_call(args, kwargs).toBool()