Fix emitter bug which doesn't allow input lists to delegates (#282)

Summary:
Pull Request resolved: #282

As the delegate op doesn't have a schema we pass in `None` here when emitting the delegate arguments.

https://www.internalfb.com/code/fbsource/[4c61670ae0bd654ca630c2288f685d3a4dfa8ece]/fbcode/executorch/exir/emit/_emitter.py?lines=954

`emit_list` expects a `val_type` to be passed in though and triggers an assert when `None` is passed in.

https://www.internalfb.com/code/fbsource/[4c61670ae0bd654ca630c2288f685d3a4dfa8ece]/fbcode/executorch/exir/emit/_emitter.py?lines=471

To handle this we try to infer the `JitType` for lists using the newly added function `_get_list_jit_type`.

Reviewed By: cccclai

Differential Revision: D49180438

fbshipit-source-id: 44d6ab1fdaecdd74ec784d2b3e8e7b15fb63c9d4

Author: tarun292

exir/emit/_emitter.py

@@ -448,6 +448,30 @@ def _get_buffer_idx(spec: TensorSpec, program_state: _ProgramState) -> int:
         # For constant tensors, allocation_info = None.
         return EValue(make_tensor_value(buffer_idx, None, spec))
 
+    def _get_list_jit_type(self, val: List[_Argument]) -> _SchemaType:
+        """Returns the JIT type for the given python type."""
+        assert isinstance(
+            val, list
+        ), f"Input to _get_list_jit_type was expected to be an instance of list but received {type(val)}"
+        is_tensor_type = all(
+            isinstance(v, _AbstractValue) and v.tensor is not None for v in val
+        )
+        if is_tensor_type:
+            return torch.TensorType.get()
+        elif isinstance(val[0], int):
+            return torch.IntType.get()
+        elif isinstance(val[0], bool):
+            return torch.BoolType.get()
+        elif isinstance(val[0], float):
+            return torch.FloatType.get()
+
+        raise InternalError(
+            self._emit_node_specific_error(
+                self.node,
+                "Couldn't determine JitType for list of elements. Only supports int, float, bool, and Tensor.",
+            )
+        )
+
     def _constant_to_evalue(  # noqa: C901
         self,
         val: _Argument,
@@ -465,6 +489,8 @@ def _constant_to_evalue(  # noqa: C901
         if isinstance(val, list):
             # Refine Optional[List[T]] -> List[T] This works because if the val was None it would
             # have converted to Null before this function call.
+            if val_type is None:
+                val_type = torch.ListType(self._get_list_jit_type(val))  # pyre-ignore
             if type(val_type) == torch.OptionalType:
                 val_type = val_type.getElementType()
             assert type(val_type) == torch.ListType

exir/emit/test/TARGETS

@@ -13,6 +13,7 @@ python_unittest(
         "//executorch/exir:lib",
         "//executorch/exir:print_program",
         "//executorch/exir:schema",
+        "//executorch/exir/backend:backend_api",
         "//executorch/exir/emit:lib",
         "//executorch/exir/passes:const_prop_pass",
         "//executorch/exir/tests:lib",

exir/emit/test/test_emit.py

@@ -16,6 +16,8 @@
 import executorch.exir.tests.models as models
 import torch
 from executorch.exir import CaptureConfig, EdgeCompileConfig, ExecutorchProgram
+from executorch.exir.backend.backend_api import to_backend
+from executorch.exir.backend.backend_details import BackendDetails, PreprocessResult
 from executorch.exir.emit import emit_program  # noqa
 from executorch.exir.error import InternalError
 from executorch.exir.passes.const_prop_pass import ConstPropPass
@@ -42,6 +44,7 @@
     _load_for_executorch_from_buffer,
 )
 from functorch.experimental import control_flow
+from torch import nn
 
 
 class TestEmit(unittest.TestCase):
@@ -1197,3 +1200,47 @@ def forward(self, x: torch.Tensor) -> torch.Tensor:
             idx,
             node.meta.get("debug_handle"),
         )
+
+    def test_delegate_with_input_list(self) -> None:
+        class BackendWithCompilerDemo(BackendDetails):
+            @staticmethod
+            def preprocess(
+                edge_program,
+                compile_specs,
+            ) -> bytes:
+                return PreprocessResult(
+                    processed_bytes=bytes(str("test"), encoding="utf8"),
+                    debug_handle_map=None,
+                )
+
+        class TestModel(nn.Module):
+            def __init__(self):
+                super(TestModel, self).__init__()
+
+            def forward(self, x):
+                return torch.cat(x)
+
+        inputs = ([torch.ones(2, 2), torch.ones(2, 2)],)
+        model = TestModel()
+        edgeir_m = exir.capture(model, inputs, exir.CaptureConfig()).to_edge(
+            exir.EdgeCompileConfig(_check_ir_validity=False)
+        )
+        lowered_module = to_backend(
+            "BackendWithCompilerDemo", edgeir_m.exported_program, None
+        )
+
+        class CompositeModule(torch.nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.lowered_module = lowered_module
+
+            def forward(self, list_a):
+                return self.lowered_module(list_a)
+
+        composite_model = CompositeModule()
+        exec_prog = (
+            exir.capture(composite_model, inputs, exir.CaptureConfig())
+            .to_edge()
+            .to_executorch()
+        )
+        exec_prog.buffer