add hasattr() (pytorch#29332)

Summary:
Pull Request resolved: pytorch#29332

Even though we're statically typed, this can be useful, e.g. as
shorthand when iterating through a module list.

Test Plan: Imported from OSS

Differential Revision: D18393097

Pulled By: suo

fbshipit-source-id: aa42e955f88d1b8a876d0727055eb596453b9839

Author: suo

aten/src/ATen/core/interned_strings.h

@@ -112,6 +112,7 @@ namespace c10 {
   _(prim, CreateObject)              \
   _(prim, SetAttr)                   \
   _(prim, GetAttr)                   \
+  _(prim, HasAttr)                   \
   _(prim, profile)                   \
   _(prim, AddStatValue)              \
   _(prim, TimePoint)                 \

test/jit/test_builtins.py

@@ -0,0 +1,74 @@
+import os
+import sys
+from typing import List
+
+import torch
+
+# Make the helper files in test/ importable
+pytorch_test_dir = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+sys.path.append(pytorch_test_dir)
+from jit_utils import JitTestCase
+
+if __name__ == '__main__':
+    raise RuntimeError("This test file is not meant to be run directly, use:\n\n"
+                       "\tpython test/test_jit.py TESTNAME\n\n"
+                       "instead.")
+
+class TestBuiltins(JitTestCase):
+    """
+    Tests for TorchScript support of Python builtin functions.
+    """
+    def test_has_attr(self):
+        class HasA(torch.nn.Module):
+            def __init__(self):
+                super(HasA, self).__init__()
+                self.a = 0
+
+        class HasB(torch.nn.Module):
+            def __init__(self):
+                super(HasB, self).__init__()
+                self.b = 1
+
+        class Mod(torch.nn.Module):
+            def __init__(self):
+                super(Mod, self).__init__()
+                self.mods = torch.nn.ModuleList([HasA(), HasB()])
+
+            def forward(self):
+                # use a list to encode hasattr results
+                l = torch.jit.annotate(List[int], [])
+                for mod in self.mods:
+                    l.append(int(hasattr(mod, "a")))
+                    l.append(int(hasattr(mod, "b")))
+                    # actually retrieve the attr to test static refinement
+                    if hasattr(mod, "a"):
+                        l.append(mod.a)
+                    if hasattr(mod, "b"):
+                        l.append(mod.b)
+                return l
+
+        self.checkModule(Mod(), ())
+
+    def test_has_attr_invalid_args(self):
+        class Mod(torch.nn.Module):
+            def __init__(self):
+                super(Mod, self).__init__()
+                self.mod = torch.nn.Linear(1, 1)
+
+            def forward(self, name):
+                # not allowed, `name` must be static.
+                return hasattr(self.mod, name)
+
+        with self.assertRaisesRegex(RuntimeError, "hasattr"):
+            torch.jit.script(Mod())
+
+        class Mod(torch.nn.Module):
+            def __init__(self):
+                super(Mod, self).__init__()
+
+            def forward(self, name):
+                # not allowed, `torch.rand` is not a class type
+                return hasattr(torch.rand(2, 3), name)
+
+        with self.assertRaisesRegex(RuntimeError, "hasattr"):
+            torch.jit.script(Mod())

test/test_jit.py

@@ -20,6 +20,7 @@
 from jit.test_custom_operators import TestCustomOperators  # noqa: F401
 from jit.test_export_modes import TestExportModes  # noqa: F401
 from jit.test_class_type import TestClassType  # noqa: F401
+from jit.test_builtins import TestBuiltins  # noqa: F401
 
 # Torch
 from torch import Tensor
@@ -15943,6 +15944,7 @@ def foo(a):
 
         with self.assertRaisesRegex(RuntimeError, "Inferred \'a\' to be of type \'Tensor"):
             foo(1)
+
 # known to be failing in tracer
 EXCLUDE_TRACED = {
     # The following fail due to #12024.

torch/csrc/jit/script/compiler.cpp

@@ -439,6 +439,7 @@ struct Environment {
                "__str__",
                std::make_shared<CastValue>(StringType::get(), aten::str))},
           {"getattr", SpecialFormValue::create(prim::GetAttr)},
+          {"hasattr", SpecialFormValue::create(prim::HasAttr)},
           {"isinstance", SpecialFormValue::create(prim::isinstance)},
           // todo(zach): remove when we can correctly export torch.full via ONNX
           // or we have implicit conversion that can convert numbers to tensors
@@ -1050,10 +1051,15 @@ struct to_ir {
         if (expr.kind() == TK_APPLY) {
           auto apply = Apply(expr);
           auto callee = Apply(expr).callee();
-          if (callee.kind() == TK_VAR &&
-              Var(callee).name().name() == "isinstance") {
-            checkApplyNumInputs(apply, 2);
-            return emitIsInstance(apply.inputs()[0], apply.inputs()[1]);
+          if (callee.kind() == TK_VAR) {
+            if (Var(callee).name().name() == "isinstance") {
+              checkApplyNumInputs(apply, 2);
+              return emitIsInstance(apply.inputs()[0], apply.inputs()[1]);
+            }
+            if (Var(callee).name().name() == "hasattr") {
+              checkApplyNumInputs(apply, 2);
+              return emitHasAttr(apply.inputs()[0], apply.inputs()[1]);
+            }
           }
         }
         return CondValue(
@@ -1401,7 +1407,26 @@ struct to_ir {
     }
   }
 
-  CondValue emitIsInstance(Expr obj, Expr classinfo) {
+  CondValue emitHasAttr(const Expr& objExpr, const Expr& attrExpr) {
+    auto obj = emitExpr(objExpr);
+    const auto& type = obj->type();
+    if (attrExpr.kind() != TK_STRINGLITERAL) {
+      throw ErrorReport(attrExpr)
+          << "hasattr's second argument must be a string literal";
+    }
+    auto cls = type->cast<ClassType>();
+    if (!cls) {
+      throw ErrorReport(objExpr)
+          << "hasattr's first argument must be an object, got "
+          << type->python_str() << " instead";
+    }
+
+    const std::string& name = StringLiteral(attrExpr).text();
+    const bool hasAttr = cls->hasAttribute(name);
+    return CondValue(*graph, objExpr.range(), hasAttr, {});
+  }
+
+  CondValue emitIsInstance(const Expr& obj, const Expr& classinfo) {
     // turn (float, (int, tuple)) into a flat list of types and type kind
     // category checks: tuple_check = true, types = {float, int}
     struct GatheredTypes {
@@ -2401,6 +2426,11 @@ struct to_ir {
         auto result = emitIsInstance(apply.inputs()[0], apply.inputs()[1]);
         return std::make_shared<SimpleValue>(result.value());
       }
+      case prim::HasAttr: {
+        checkApplyNumInputs(apply, 2);
+        const auto result = emitHasAttr(apply.inputs()[0], apply.inputs()[1]);
+        return std::make_shared<SimpleValue>(result.value());
+      } break;
       // This represents the "__new__" method on classes
       // because it takes a ClassValue as input.
       // So if we see: