[JIT] Allow implicit boolean conversion of containers (pytorch#51683)

Summary:
Pull Request resolved: pytorch#51683

**Summary**
This commit enables implicit boolean conversion of lists, strings, and
dictionaries in conditional expressions. Like Python, empty lists,
strings and dictionaries evaluate to `False` and their non-empty
counterparts evaluate to `True`. This allows users to write code like

```
torch.jit.script
def fn(l: List[int]):
  if l:
    ...
  else:
    ...
```

This has been requested by some users and would be a good usability
improvement.

**Test Plan**
This commit adds unit tests to `TestList`, `TestDict` and
`test_jit_string.py` to test this new feature.

Test Plan: Imported from OSS

Reviewed By: pbelevich

Differential Revision: D26264410

Pulled By: SplitInfinity

fbshipit-source-id: b764c18fd766cfc128ea98a02b7c6c3fa49f8632

Author: Meghan Lele

test/jit/test_list_dict.py

@@ -20,6 +20,35 @@
                        "instead.")
 
 class TestList(JitTestCase):
+    def test_list_bool_conversion(self):
+        def if_predicate(l: List[int]):
+            if l:
+                s = 0
+                for n in l:
+                    s += n
+
+                return s
+            else:
+                return -1
+
+        self.checkScript(if_predicate, ([1, 2, 3],))
+        self.checkScript(if_predicate, ([],))
+
+        def while_predicate(l: List[int]):
+            s = 0
+
+            while l:
+                s += l.pop()
+
+        self.checkScript(while_predicate, ([1, 2, 3],))
+        self.checkScript(while_predicate, ([],))
+
+        def ternary_predicate(l: List[int]):
+            return "non-empty" if l else "empty"
+
+        self.checkScript(ternary_predicate, ([1, 2, 3],))
+        self.checkScript(ternary_predicate, ([],))
+
     def test_in_check(self):
         def int_in(x: List[int]) -> bool:
             return 2 in x
@@ -1175,6 +1204,34 @@ def dict2(self):
     def dict_bool(self):
         return {True: 1}
 
+    def test_dict_bool_conversion(self):
+        def if_predicate(d: Dict[int, int]):
+            if d:
+                s, t = 0, 0
+                for k, v in d.items():
+                    s += k
+                    t += v
+
+                return s, t
+            else:
+                return -1, -1
+
+        self.checkScript(if_predicate, ({1: 2, 3: 5},))
+        self.checkScript(if_predicate, ({},))
+
+        def while_predicate(d: Dict[int, int]):
+            while d:
+                d.clear()
+
+        self.checkScript(while_predicate, ({1: 2, 3: 5},))
+        self.checkScript(while_predicate, ({},))
+
+        def ternary_predicate(d: Dict[int, int]):
+            return "non-empty" if d else "empty"
+
+        self.checkScript(ternary_predicate, ({1: 2, 3: 5},))
+        self.checkScript(ternary_predicate, ({},))
+
     def test_del(self):
         def inputs():
             return {'hi': 2, 'bye': 3}

test/test_jit_string.py

@@ -306,5 +306,14 @@ def test_str_join():
             )
         self.checkScript(test_str_join, ())
 
+        def test_bool_conversion(a: str):
+            if a:
+                return a
+            else:
+                return "default"
+
+        self.checkScript(test_bool_conversion, ("nonempty",))
+        self.checkScript(test_bool_conversion, ("",))
+
 if __name__ == '__main__':
     run_tests()

torch/csrc/jit/frontend/sugared_value.h

@@ -511,9 +511,20 @@ struct TORCH_API CastValue : public BuiltinFunction {
       at::ArrayRef<NamedValue> kwargs,
       size_t n_binders) override {
     if (args.size() == 1 && kwargs.size() == 0) {
+      auto len_op = std::make_shared<BuiltinFunction>(aten::len, at::nullopt);
+      auto gt_op = std::make_shared<BuiltinFunction>(aten::gt, at::nullopt);
+      auto zero = m.graph()->insertConstant(0);
+
       auto v = args[0].value(*m.graph());
       if (v->type()->isSubtypeOf(type_)) {
         return std::make_shared<SimpleValue>(v);
+      } else if (
+          *type_ == *BoolType::get() &&
+          (v->type()->isSubtypeOf(AnyListType::get()) ||
+           v->type()->isSubtypeOf(StringType::get()) ||
+           v->type()->cast<DictType>())) {
+        auto len = len_op->call(loc, m, {v}, {}, 1);
+        return gt_op->call(loc, m, {len->asValue(loc, m), zero}, {}, 1);
       }
     }
     return BuiltinFunction::call(loc, m, args, kwargs, n_binders);