Compress non-simple alternative getattr calls into a function call.

Author: braxtonmckee

typed_python/compiler/tests/alternative_compilation_test.py

@@ -1754,3 +1754,34 @@ def eq(a1: AB, a2: AB):
         assert eq(AB.A(a=1), AB.A(a=1))
         assert eqMixed(AB.A(a=1), AB.A(a=1))
         assert eqConcrete(AB.A(a=1), AB.A(a=1))
+
+    def test_compiled_attribute_access(self):
+        A = Alternative(
+            "A",
+            X=dict(x=int, y=str, z=str),
+            Y=dict(x=int, y=str, z=float),
+            Z=dict(),
+        )
+
+        def getx(a: A):
+            try:
+                return a.x
+            except Exception:
+                return 'None'
+
+        def gety(a: A):
+            try:
+                return a.y
+            except Exception:
+                return 'None'
+
+        def getz(a: A):
+            try:
+                return a.z
+            except Exception:
+                return 'None'
+
+        for a in [A.X(x=1, y='2', z='3'), A.Y(x=1, y='2', z=3), A.Z()]:
+            assert getx(a) == Entrypoint(getx)(a)
+            assert gety(a) == Entrypoint(gety)(a)
+            assert getz(a) == Entrypoint(getz)(a)

typed_python/compiler/type_wrappers/alternative_wrapper.py

@@ -364,17 +364,40 @@ def convert_attribute(self, context, instance, attribute, nocheck=False):
         else:
             outputType = mergeTypeWrappers(possibleTypes)
 
-            output = context.allocateUninitializedSlot(outputType)
+            native = context.converter.defineNativeFunction(
+                'getattr(' + self.typeRepresentation.__name__ + ", " + attribute + ")",
+                ('getattr', self, attribute),
+                [self],
+                outputType,
+                lambda context, out, instance: self.generateNativeGetattr(
+                    context, outputType, validIndices, out, instance, attribute
+                )
+            )
+
+            if outputType.is_pass_by_ref:
+                return context.push(
+                    outputType,
+                    lambda out: native.call(out, instance)
+                )
+            else:
+                return context.pushPod(
+                    outputType,
+                    native.call(instance)
+                )
+
+    def generateNativeGetattr(self, context, outputType, validIndices, out, instance, attr):
+        which = instance.nonref_expr.ElementPtrIntegers(0, 1).load()
+        for ix in validIndices:
+            with context.ifelse(which.eq(ix)) as (ifTrue, ifFalse):
+                with ifTrue:
+                    res = self.refAs(context, instance, ix).convert_attribute(attr)
+                    if res is not None:
+                        res = res.convert_to_type(outputType, ConversionLevel.Signature)
 
-            with context.switch(instance.nonref_expr.ElementPtrIntegers(0, 1).load(), validIndices, False) as indicesAndContexts:
-                for ix, subcontext in indicesAndContexts:
-                    with subcontext:
-                        attr = self.refAs(context, instance, ix).convert_attribute(attribute)
-                        attr = attr.convert_to_type(outputType, ConversionLevel.Signature)
-                        output.convert_copy_initialize(attr)
-                        context.markUninitializedSlotInitialized(output)
+                    context.pushReturnValue(res)
 
-            return output
+        if len(validIndices) != len(self.alternatives):
+            context.pushException(AttributeError, attr)
 
     def convert_check_matches(self, context, instance, typename):
         index = -1