Ensure we can add untyped tuples to List/TupleOf in the compiler.

Author: braxtonmckee

typed_python/compiler/tests/list_of_compilation_test.py

@@ -787,3 +787,15 @@ def assignIt(l, x):
 
         with self.assertRaises(TypeError):
             aList[0] = "hi"
+
+    def test_add_untyped_tuple(self):
+        @Entrypoint
+        def addIt(aTup: ListOf(int), x: int):
+            return aTup + (x,)
+
+        @Entrypoint
+        def addItLst(aTup: ListOf(int), x: int):
+            return aTup + [x]
+
+        assert addIt((1, 2), 3) == [1, 2, 3]
+        assert addItLst((1, 2), 3) == [1, 2, 3]

typed_python/compiler/tests/tuple_of_compilation_test.py

@@ -232,3 +232,28 @@ def sliceIt(aTup: TupleOf(int), x: int):
             return aTup[:x]
 
         assert sliceIt((1, 2, 3), 1) == (1,)
+
+    def test_add_untyped_tuple(self):
+        @Entrypoint
+        def addIt(aTup: TupleOf(int), x: int):
+            return aTup + (x,)
+
+        @Entrypoint
+        def addItLst(aTup: TupleOf(int), x: int):
+            return aTup + [x]
+
+        assert addIt((1, 2), 3) == (1, 2, 3)
+        assert addItLst((1, 2), 3) == (1, 2, 3)
+
+    def test_add_untyped_tuple_reversed(self):
+        @Entrypoint
+        def addIt(aTup: TupleOf(int), x: int):
+            return (x,) + aTup
+
+        @Entrypoint
+        def addItLst(aTup: TupleOf(int), x: int):
+            return [x] + aTup
+
+        assert addIt((1, 2), 3) == (3, 1, 2)
+        assert addItLst((1, 2), 3) == (3, 1, 2)
+

typed_python/compiler/type_wrappers/tuple_of_wrapper.py

@@ -218,6 +218,24 @@ def concatenate_tuple_or_list(l, r):
     return result
 
 
+def concatenate_tuple_or_list_reversed(l, r):
+    result = PreReservedTupleOrList(type(r))(len(l) + len(r))
+
+    ix = 0
+
+    for item in l:
+        result._initializeItemUnsafe(ix, item)
+        ix += 1
+        result.setSizeUnsafe(ix)
+
+    for item in r:
+        result._initializeItemUnsafe(ix, item)
+        ix += 1
+        result.setSizeUnsafe(ix)
+
+    return result
+
+
 def list_or_tupleof_of_slice(aList, start, stop, step):
     if step is None:
         return list_or_tupleof_of_slice(aList, start, stop, 1)
@@ -338,7 +356,7 @@ def generateNativeDestructorFunction(self, context, out, inst):
         )
 
     def convert_bin_op(self, context, left, op, right, inplace):
-        if issubclass(right.expr_type.typeRepresentation, (TupleOf, ListOf)):
+        if issubclass(right.expr_type.typeRepresentation, (TupleOf, ListOf, Tuple, NamedTuple)):
             if op.matches.Add:
                 return context.call_py_function(concatenate_tuple_or_list, (left, right), {})
 
@@ -359,6 +377,10 @@ def convert_bin_op(self, context, left, op, right, inplace):
         return super().convert_bin_op(context, left, op, right, inplace)
 
     def convert_bin_op_reverse(self, context, right, op, left, inplace):
+        if issubclass(right.expr_type.typeRepresentation, (TupleOf, ListOf, Tuple, NamedTuple)):
+            if op.matches.Add:
+                return context.call_py_function(concatenate_tuple_or_list_reversed, (left, right), {})
+
         if op.matches.In or op.matches.NotIn:
             left = left.convert_to_type(self.typeRepresentation.ElementType, ConversionLevel.Implicit)