[libclang] Add support for checking abstractness of records

[jklaehn]

Summary

This patch allows checking whether a C++ record declaration is abstract through libclang and clang.cindex (Python).

[jklaehn]

ping :)

[jklaehn]

ping (rebased)

[arphaman]

LGTM

[jklaehn]

In D36952#951616, @arphaman wrote:

LGTM

Thanks! Can you submit this for me? (I do not have commit access yet.)

[arphaman]

Sure, I'll do it today.

[jklaehn]

Thanks! However, compared to diff 126298 (https://reviews.llvm.org/differential/diff/126298/), there seems to be duplication in the committed change (maybe some artifacts due to rebasing/merging?). Should I submit a follow-up patch to fix this?

cfe/trunk/bindings/python/clang/cindex.py

1488

duplicate

3420

duplicate

cfe/trunk/bindings/python/tests/cindex/test_cursor.py

289

duplicate

[arphaman]

In D36952#955937, @jklaehn wrote:

Thanks! However, compared to diff 126298 (https://reviews.llvm.org/differential/diff/126298/), there seems to be duplication in the committed change (maybe some artifacts due to rebasing/merging?). Should I submit a follow-up patch to fix this?

Hmm, I think the patch applied incorrectly on my side. I can fix this.

[arphaman]

Fixed in r320766. Sorry about that!

cfe/trunk/bindings/python/clang/cindex.py

def is_static_method(self):
         return conf.lib.clang_CXXMethod_isStatic(self)
 
     def is_virtual_method(self):
         """Returns True if the cursor refers to a C++ member function or member
         function template that is declared 'virtual'.
         """
         return conf.lib.clang_CXXMethod_isVirtual(self)
 
+    def is_abstract_record(self):
+        """Returns True if the cursor refers to a C++ record declaration
+        that has pure virtual member functions.
+        """
+        return conf.lib.clang_CXXRecord_isAbstract(self)
+
+    def is_abstract_record(self):
+        """Returns True if the cursor refers to a C++ record declaration
+        that has pure virtual member functions.
+        """
+        return conf.lib.clang_CXXRecord_isAbstract(self)
+
     def is_scoped_enum(self):
         """Returns True if the cursor refers to a scoped enum declaration.
         """
         return conf.lib.clang_EnumDecl_isScoped(self)
 
     def get_definition(self):
         """
         If the cursor is a reference to a declaration or a declaration of
functionList = [
   ("clang_CXXMethod_isStatic",
    [Cursor],
    bool),
 
   ("clang_CXXMethod_isVirtual",
    [Cursor],
    bool),
 
+  ("clang_CXXRecord_isAbstract",
+   [Cursor],
+   bool),
+
+  ("clang_CXXRecord_isAbstract",
+   [Cursor],
+   bool),
+
   ("clang_EnumDecl_isScoped",
    [Cursor],
    bool),
 
   ("clang_defaultDiagnosticDisplayOptions",
    [],
    c_uint),
 

cfe/trunk/bindings/python/tests/cindex/test_cursor.py

def test_is_virtual_method(self):
         bar = get_cursor(tu, 'bar')
         self.assertIsNotNone(cls)
         self.assertIsNotNone(foo)
         self.assertIsNotNone(bar)
 
         self.assertTrue(foo.is_virtual_method())
         self.assertFalse(bar.is_virtual_method())
 
+    def test_is_abstract_record(self):
+        """Ensure Cursor.is_abstract_record works."""
+        source = 'struct X { virtual void x() = 0; }; struct Y : X { void x(); };'
+        tu = get_tu(source, lang='cpp')
+
+        cls = get_cursor(tu, 'X')
+        self.assertTrue(cls.is_abstract_record())
+
+        cls = get_cursor(tu, 'Y')
+        self.assertFalse(cls.is_abstract_record())
+
+    def test_is_abstract_record(self):
+        """Ensure Cursor.is_abstract_record works."""
+        source = 'struct X { virtual void x() = 0; }; struct Y : X { void x(); };'
+        tu = get_tu(source, lang='cpp')
+
+        cls = get_cursor(tu, 'X')
+        self.assertTrue(cls.is_abstract_record())
+
+        cls = get_cursor(tu, 'Y')
+        self.assertFalse(cls.is_abstract_record())
+
     def test_is_scoped_enum(self):
         """Ensure Cursor.is_scoped_enum works."""
         source = 'class X {}; enum RegularEnum {}; enum class ScopedEnum {};'
         tu = get_tu(source, lang='cpp')
 
         cls = get_cursor(tu, 'X')
         regular_enum = get_cursor(tu, 'RegularEnum')
         scoped_enum = get_cursor(tu, 'ScopedEnum')

cfe/trunk/include/clang-c/Index.h

  * \brief The version constants for the libclang API.
  * CINDEX_VERSION_MINOR should increase when there are API additions.
  * CINDEX_VERSION_MAJOR is intended for "major" source/ABI breaking changes.
  *
  * The policy about the libclang API was always to keep it source and ABI
  * compatible, thus CINDEX_VERSION_MAJOR is expected to remain stable.
  */
 #define CINDEX_VERSION_MAJOR 0
-#define CINDEX_VERSION_MINOR 44
+#define CINDEX_VERSION_MINOR 45
 
 #define CINDEX_VERSION_ENCODE(major, minor) ( \
       ((major) * 10000)                       \
     + ((minor) *     1))
 
 #define CINDEX_VERSION CINDEX_VERSION_ENCODE( \
     CINDEX_VERSION_MAJOR,                     \
     CINDEX_VERSION_MINOR )

 /**
  * \brief Determine if a C++ member function or member function template is
  * explicitly declared 'virtual' or if it overrides a virtual method from
  * one of the base classes.
  */
 CINDEX_LINKAGE unsigned clang_CXXMethod_isVirtual(CXCursor C);
 
 /**
+ * \brief Determine if a C++ record is abstract, i.e. whether a class or struct
+ * has a pure virtual member function.
+ */
+CINDEX_LINKAGE unsigned clang_CXXRecord_isAbstract(CXCursor C);
+
+/**
  * \brief Determine if an enum declaration refers to a scoped enum.
  */
 CINDEX_LINKAGE unsigned clang_EnumDecl_isScoped(CXCursor C);
 
 /**
  * \brief Determine if a C++ member function or member function template is
  * declared 'const'.
  */

cfe/trunk/test/Index/load-classes.cpp

private:
   friend void friendFunctionTemplate();
   friend class F;
 };
 
 X::X(int value) {
 }
 
 // RUN: c-index-test -test-load-source all %s | FileCheck %s
-// CHECK: load-classes.cpp:3:8: StructDecl=X:3:8 (Definition) Extent=[3:1 - 26:2]
+// CHECK: load-classes.cpp:3:8: StructDecl=X:3:8 (Definition) (abstract) Extent=[3:1 - 26:2]
 // CHECK: load-classes.cpp:4:3: CXXConstructor=X:4:3 (converting constructor) Extent=[4:3 - 4:15] [access=public]
 // FIXME: missing TypeRef in the constructor name
 // CHECK: load-classes.cpp:4:9: ParmDecl=value:4:9 (Definition) Extent=[4:5 - 4:14]
 // CHECK: load-classes.cpp:5:3: CXXConstructor=X:5:3 (copy constructor) (converting constructor) Extent=[5:3 - 5:16] [access=public]
 // FIXME: missing TypeRef in the constructor name
 // CHECK: load-classes.cpp:5:14: ParmDecl=x:5:14 (Definition) Extent=[5:5 - 5:15]
 // CHECK: load-classes.cpp:5:11: TypeRef=struct X:3:8 Extent=[5:11 - 5:12]
 // CHECK: load-classes.cpp:6:1: CXXAccessSpecifier=:6:1 (Definition) Extent=[6:1 - 6:11] [access=protected]

cfe/trunk/tools/c-index-test/c-index-test.c

else {
     if (clang_CXXMethod_isStatic(Cursor))
       printf(" (static)");
     if (clang_CXXMethod_isVirtual(Cursor))
       printf(" (virtual)");
     if (clang_CXXMethod_isConst(Cursor))
       printf(" (const)");
     if (clang_CXXMethod_isPureVirtual(Cursor))
       printf(" (pure)");
+    if (clang_CXXRecord_isAbstract(Cursor))
+      printf(" (abstract)");
     if (clang_EnumDecl_isScoped(Cursor))
       printf(" (scoped)");
     if (clang_Cursor_isVariadic(Cursor))
       printf(" (variadic)");
     if (clang_Cursor_isObjCOptional(Cursor))
       printf(" (@optional)");
 
     switch (clang_getCursorExceptionSpecificationType(Cursor))

cfe/trunk/tools/libclang/CIndex.cpp

if (!clang_isDeclaration(C.kind))
     return 0;
   
   const Decl *D = cxcursor::getCursorDecl(C);
   const CXXMethodDecl *Method =
       D ? dyn_cast_or_null<CXXMethodDecl>(D->getAsFunction()) : nullptr;
   return (Method && Method->isVirtual()) ? 1 : 0;
 }
 
+unsigned clang_CXXRecord_isAbstract(CXCursor C) {
+  if (!clang_isDeclaration(C.kind))
+    return 0;
+
+  const auto *D = cxcursor::getCursorDecl(C);
+  const auto *RD = dyn_cast_or_null<CXXRecordDecl>(D);
+  if (RD)
+    RD = RD->getDefinition();
+  return (RD && RD->isAbstract()) ? 1 : 0;
+}
+
 unsigned clang_EnumDecl_isScoped(CXCursor C) {
   if (!clang_isDeclaration(C.kind))
     return 0;
 
   const Decl *D = cxcursor::getCursorDecl(C);
   auto *Enum = dyn_cast_or_null<EnumDecl>(D);
   return (Enum && Enum->isScoped()) ? 1 : 0;
 }

cfe/trunk/tools/libclang/libclang.exports

 clang_CXCursorSet_contains
 clang_CXCursorSet_insert
 clang_CXIndex_getGlobalOptions
 clang_CXIndex_setGlobalOptions
 clang_CXIndex_setInvocationEmissionPathOption
 clang_CXXConstructor_isConvertingConstructor
 clang_CXXConstructor_isCopyConstructor
 clang_CXXConstructor_isDefaultConstructor
 clang_CXXConstructor_isMoveConstructor
 clang_CXXField_isMutable
 clang_CXXMethod_isDefaulted
 clang_CXXMethod_isConst
 clang_CXXMethod_isPureVirtual
 clang_CXXMethod_isStatic
 clang_CXXMethod_isVirtual
+clang_CXXRecord_isAbstract
 clang_EnumDecl_isScoped
 clang_Cursor_getArgument
 clang_Cursor_getNumTemplateArguments
 clang_Cursor_getTemplateArgumentKind
 clang_Cursor_getTemplateArgumentType
 clang_Cursor_getTemplateArgumentValue
 clang_Cursor_getTemplateArgumentUnsignedValue
 clang_Cursor_getBriefCommentText