accumulated already-submitted changes

Author: rwgk

clif/backend/matcher.cc

@@ -2989,20 +2989,20 @@ const clang::FunctionDecl* ClifMatcher::SpecializeFunctionTemplate(
 }
 
 std::string ClifMatcher::TemplateDeductionResult(
-    Sema::TemplateDeductionResult specialized_result) const {
+    clang::TemplateDeductionResult specialized_result) const {
   switch (specialized_result) {
-    case Sema::TDK_Invalid:
+    case clang::TemplateDeductionResult::Invalid:
       return "The template function declaration was invalid.";
-    case Sema::TDK_InstantiationDepth:
+    case clang::TemplateDeductionResult::InstantiationDepth:
       return "Template argument deduction exceeded the maximum template "
              "instantiation depth.";
-    case Sema::TDK_Incomplete:
+    case clang::TemplateDeductionResult::Incomplete:
       return "Template argument deduction did not deduce a value for every "
              "template parameter.";
-    case Sema::TDK_Inconsistent:
+    case clang::TemplateDeductionResult::Inconsistent:
       return "Template argument deduction produced inconsistent deduced "
              "values.";
-    case Sema::TDK_Underqualified:
+    case clang::TemplateDeductionResult::Underqualified:
       return "Template argument deduction failed due to inconsistent "
              "cv-qualifiers.";
     default:

clif/backend/matcher.h

@@ -402,7 +402,7 @@ class ClifMatcher {
 
   // Transform template type deduction error codes into error messages.
   std::string TemplateDeductionResult(
-      clang::Sema::TemplateDeductionResult specialized_result) const;
+      clang::TemplateDeductionResult specialized_result) const;
 
   // Add the class type as the first parameter to a function.
   void AdjustForNonClassMethods(protos::FuncDecl* clif_func_decl) const;

clif/pybind11/classes.py

@@ -26,6 +26,8 @@
 
 I = utils.I
 
+_USE_PYTYPE_TYPE_AS_METACLASS = True
+
 _KNOWN_TYPES_WITH_MULTIPLE_INHERITANCE = {
     '::borg::Config': ['::borg::ConfigArgs']
 }
@@ -100,6 +102,8 @@ def generate_from(
         base.cpp_canonical_type in codegen_info.dynamic_attr_types):
       enable_instance_dict = True
       break
+  if _USE_PYTYPE_TYPE_AS_METACLASS:
+    definition += ', py::metaclass((PyObject*) &PyType_Type)'
   definition += ', py::release_gil_before_calling_cpp_dtor()'
   if mi_bases:
     definition += ', py::multiple_inheritance()'
@@ -117,7 +121,7 @@ def generate_from(
   for member in class_decl.members:
     if member.decltype == ast_pb2.Decl.Type.CONST:
       for s in consts.generate_from(class_name, member.const):
-        yield I + I + s
+        yield I + s
     elif member.decltype == ast_pb2.Decl.Type.FUNC:
       if member.func.name.native in ('__reduce__', '__reduce_ex__'):
         reduce_or_reduce_ex_defined = True

clif/python/BUILD

@@ -1,6 +1,7 @@
 # CLIF python frontend
 
 load("@clif_python_deps//:requirements.bzl", "requirement")
+load("//devtools/clif/python:clif_build_rule.bzl", "py_clif_cc")
 load("//third_party/bazel_rules/rules_python/python:py_test.bzl", "py_test")
 
 package(
@@ -412,3 +413,25 @@ py_library(
     srcs_version = "PY2AND3",
     visibility = ["//visibility:public"],
 )
+
+cc_library(
+    name = "meta_ext_lib",
+    hdrs = ["meta_ext.h"],
+)
+
+py_clif_cc(
+    name = "_meta_ext",
+    srcs = ["meta_ext.clif"],
+    deps = [
+        ":meta_ext_lib",
+    ],
+)
+
+py_library(
+    name = "abc_utils",
+    srcs = ["abc_utils.py"],
+    visibility = ["//visibility:public"],
+    deps = [
+        ":_meta_ext",
+    ],
+)

clif/python/primer.md

@@ -713,8 +713,8 @@ of the return values as positional arguments. Whatever it returns becomes the
 actual return value.
 
 Some commonly needed post-processors have been provided in the above imported
-library with CLIF. You can also
-provide your own Python post-processor library.
+library with CLIF.
+You can also provide your own Python post-processor library.
 
 ## Naming Rules in CLIF Files {#naming_rules}
 

clif/python/types.cc

@@ -209,7 +209,6 @@ bool Clif_PyObjAs(PyObject* py, long* c) {  //NOLINT: runtime/int
 }
 
 // int64
-#ifdef HAVE_LONG_LONG
 bool Clif_PyObjAs(PyObject* py, long long* c) {  //NOLINT: runtime/int
   CHECK(c != nullptr);
   if (!PyLong_Check(py)) {
@@ -270,7 +269,6 @@ bool Clif_PyObjAs(PyObject* py, absl::uint128* c) {  // NOLINT: runtime/int
   }
   return !PyErr_Occurred();
 }
-#endif  // HAVE_LONG_LONG
 
 #ifdef ABSL_HAVE_INTRINSIC_INT128
 bool Clif_PyObjAs(PyObject* py, __int128* c) {

clif/python/types.h

@@ -102,7 +102,6 @@ inline PyObject* Clif_PyObjFrom(unsigned long c,  // NOLINT runtime/int
   return pc.Apply(PyLong_FromSize_t(c));
 }
 // CLIF use `int64` as int64
-#ifdef HAVE_LONG_LONG
 inline PyObject* Clif_PyObjFrom(long long c,  // NOLINT runtime/int
                                 const py::PostConv& pc) {
   return pc.Apply(PyLong_FromLongLong(c));
@@ -128,7 +127,6 @@ inline PyObject* Clif_PyObjFrom(absl::uint128 c, const py::PostConv& pc) {
   auto lo = PyLong_FromUnsignedLongLong(absl::Uint128Low64(c));
   return pc.Apply(PyNumber_Add(hi, lo));
 }
-#endif
 
 #ifdef ABSL_HAVE_INTRINSIC_INT128
 // CLIF use2 `__int128` as int
@@ -195,12 +193,10 @@ bool Clif_PyObjAs(PyObject*, unsigned char*);
 bool Clif_PyObjAs(PyObject*, unsigned short*);  // NOLINT runtime/int
 bool Clif_PyObjAs(PyObject*, unsigned int*);
 bool Clif_PyObjAs(PyObject*, unsigned long*);  // NOLINT runtime/int
-#ifdef HAVE_LONG_LONG
 bool Clif_PyObjAs(PyObject*, unsigned long long*);  // NOLINT runtime/int
 bool Clif_PyObjAs(PyObject*, long long*);           // NOLINT runtime/int
 bool Clif_PyObjAs(PyObject*, absl::int128*);        // NOLINT runtime/int
 bool Clif_PyObjAs(PyObject*, absl::uint128*);       // NOLINT runtime/int
-#endif
 #ifdef ABSL_HAVE_INTRINSIC_INT128
 bool Clif_PyObjAs(PyObject*, __int128*);
 bool Clif_PyObjAs(PyObject*, unsigned __int128*);

clif/testing/python/classes_test.py

@@ -14,11 +14,13 @@
 
 """Tests for clif.testing.python.classes."""
 
+import abc
 from unittest import mock
 
 from absl.testing import absltest
 from absl.testing import parameterized
 
+from clif.python import abc_utils
 from clif.testing.python import classes
 
 
@@ -35,6 +37,20 @@ def testKlass(self):
     # AttributeError on CPython; TypeError on PyPy.
     with self.assertRaises((AttributeError, TypeError)):
       k.i2 = 0
+    self.assertEqual(classes.Klass.C, 1)
+    self.assertEqual(k.C, 1)
+    with self.assertRaisesRegex(AttributeError, 'read-only'):
+      k.C = 0
+
+    # UNDESIRABLE but long established behavior.
+    classes.Klass.C = 0  # C++ const but not read-only in Python.
+    self.assertEqual(classes.Klass.C, 0)
+    self.assertEqual(k.C, 0)
+    # Restore original value, to minimize the potential for surprises,
+    # just in case.
+    classes.Klass.C = 1
+    self.assertEqual(classes.Klass.C, 1)
+    self.assertEqual(k.C, 1)
 
   def testMockIsRejected(self):
     k_inst = classes.Klass(3)
@@ -212,6 +228,42 @@ def testNestedUnproperty(self, attr, expected, new_value, new_expected):
     ret = getattr(obj, getter)()
     self.assertEqual(ret, new_expected)
 
+  def testABCMeta(self):
+    # Purely to help the linter.
+    ABCMeta = abc.ABCMeta  # pylint: disable=unused-variable
+
+    if abc_utils.PyCLIFMeta is type:
+
+      class KlassABCMeta(classes.Klass, metaclass=ABCMeta):
+        pass
+
+      self.assertEqual(type(classes.Klass).__name__, 'type')
+      km = KlassABCMeta(5)
+      self.assertEqual(km.i, 5)
+
+    else:
+      self.assertEqual(classes.__pyclif_codegen_mode__, 'pybind11')
+      with self.assertRaisesRegex(TypeError, 'metaclass conflict'):
+
+        class KlassABCMeta(classes.Klass, metaclass=ABCMeta):
+          pass
+
+  def testPyCLIFABCMeta(self):
+    # Purely to help the linter.
+    PyCLIFABCMeta = abc_utils.PyCLIFABCMeta  # pylint: disable=unused-variable,invalid-name
+
+    class KlassPyCLIFABCMeta(classes.Klass, metaclass=PyCLIFABCMeta):
+      pass
+
+    if abc_utils.PyCLIFMeta is type:
+      expected_type_name = 'type'
+    else:
+      self.assertEqual(classes.__pyclif_codegen_mode__, 'pybind11')
+      expected_type_name = 'pybind11_type'
+    self.assertEqual(type(classes.Klass).__name__, expected_type_name)
+    km = KlassPyCLIFABCMeta(5)
+    self.assertEqual(km.i, 5)
+
 
 if __name__ == '__main__':
   absltest.main()