Expose cxx constructor and method properties through libclang and python bindings.

[jbcoe]

Summary

I have exposed the following function through libclang and the clang.cindex python bindings:

clang_CXXConstructor_isConvertingConstructor,
clang_CXXConstructor_isCopyConstructor,
clang_CXXConstructor_isDefaultConstructor,
clang_CXXConstructor_isMoveConstructor,
clang_CXXMethod_isDefaulted

I need (some of) these methods for a C++ code model I am building in Python to drive a code generator.

[compnerd]

bindings/python/tests/cindex/test_cursor.py

137

How about adding a move constructor and verifying that we don't detect it as a copy constructor?

tools/c-index-test/c-index-test.c

778

Missing space after the comma.

780

Similar

[compnerd]

Also, it may be worthwhile to only expose what is actually needed. We can expand to the other interfaces when there is an actual need for it.

[jbcoe]

Added test as recommended in review.

[jbcoe]

I have possible need for all of the methods exposed and definite need for is_deleted.

I had thought that exposing more things through lbclang would be better, what's the motivation for exposing less?

[compnerd]

The interfaces are part of the C API, which we try to keep stable, so minimizing the exposure is ideal. However, if there is a need for it, we can absolutely add the new interfaces.

[compnerd]

Sorry, didn't catch the new test case yesterday. Really if you have a need for these interfaces, with the new test, I think that this should be fine.

test/Index/load-classes.cpp

31

Can you also add a test here for:

class c {
    explicit c(const c &);
};

This should not be reported as a converting constructor, but should be reported as a copy constructor.

[jbcoe]

I've added (locally)

class c {
    explicit c(const c &);
};

it is reported as (copy constructor) (explicit converting constructor). I think this is correct but I'm not sure if we want it to be declared as such.

I'm tempted to remove the implicit from (implicit converting constructor) and remove the '(explicit converting constructor)` altogether as I don't need it and it feels like noise rather than useful information.

[skalinichev]

test/Index/index-file.cpp

47

Shouldn't it be (default constructor) (defaulted) instead?

[jbcoe]

test/Index/index-file.cpp

47

It should. (default constructor) is currently being swallowed by the glob.

[jbcoe]

Minor additions to index tests following review

[compnerd]

In D15469#309287, @jbcoe wrote:

I'm tempted to remove the implicit from (implicit converting constructor) and remove the '(explicit converting constructor)` altogether as I don't need it and it feels like noise rather than useful information.

The printing here is for the test binary, its not what is reported to the user, and can be inferred from the information. The noise here ensures that the matching is what is supposed to be part of the interface contract. We could remove the AllowExplicit parameter to clang_CXXConstructor_isConvertingConstructor, and let the user determine via a clang_CXXConstructor_isExplicit. Im slightly leaning towards letting the user determine it themselves.

[jbcoe]

Fix formatting.

[jbcoe]

I've made all the suggested edits.

From my reading of the C++14 draft standard, a converting constructor is not explicit so defaulting the AllowExplicit flag to true seems inconsistent.

I'm happy to add clang_CXXConstructorIsExplicit if you think that's the best way to go.

[compnerd]

Yeah, that is why Im not strongly convinced its the right thing to do. I think that we could filter to the ones that are not marked explicit. According to C++11:

12.3.1: A constructor declared without the function-specifier explicit specifies a conversion from the types of its parameters to the type of its class. Such a constructor is called a converting constructor.

So, really, the additional flag seems incorrect to include.

[jbcoe]

consider_explicit defaults to False in Python bindings for is_converting_constructor.

Please let me know if you'd like further changes. I can do all the code-generation I need with the current changes.

[compnerd]

Lets go ahead and remove the parameter and not consider the explicit ones for the time being then.

[jbcoe]

Do we want it removing from Python bindings, defaulting in Python bindings (as I've done) or removing from the libclang bindings?

he latter seems cleaner but potentially an issue as those bindings are meant to be stable. I suppose someone could later add another function to access explicit converting constructors if they needed it.

[compnerd]

Exactly, I think that we can add another interface if needed in the future.

[jbcoe]

Remove ConsiderExplicit flag from CXXMethod_isConvertingConstructor.

[jbcoe]

I was wondering if further changes are needed for this PR?

[skalinichev]

Generally looks pretty good to me. Maybe it's worth to factor out duplicating code, but I guess it's not so important.

Also the index-file.cpp test failing for me:
test/Index/index-file.cpp:57:11: error: expected string not found in input
// CHECK: [indexDeclaration]: kind: c++-instance-method | name: foo | {{.*}} (deleted) | loc: 36:8

@jbcoe, can you take a look?

[compnerd]

Sorry about the delay with this change. Thanks for removing the parameter. I think that this is fine as is. Do you have commit rights, or should I commit this on your behalf?

[jbcoe]

@skalinichev I get the same failure as you. This patch is old now, all tests used to pass. Can you see what is wrong with the test logic?

[jbcoe]

I don't know if it's at all helpful but I get the following output from llvm-lit on the failing test file. There's no mention of a function foo at all:

[startedTranslationUnit]
[enteredMainFile]: /Users/jon/DEV/llvm-git-svn/tools/clang/test/Index/index-file.cpp
[indexDeclaration]: kind: type-alias | name: MyTypeAlias | USR: c:@MyTypeAlias | lang: C++ | cursor: TypeAliasDecl=MyTypeAlias:1:7 (Definition) | loc: 1:7 | semantic-container: [TU]
[indexDeclaration]: kind: function-template | name: Allocate | USR: c:@FT@>1#TAllocate | lang: C++ | cursor: FunctionDecl=Allocate:4:28 (Definition) | loc: 4:28 | semantic-container
[indexDeclaration]: kind: namespace | name: rdar14063074 | USR: c:@N@rdar14063074 | lang: C++ | cursor: Namespace=rdar14063074:8:11 (Definition) | loc: 8:11 | semantic-container: [T
[indexDeclaration]: kind: c++-class-template | name: TS | USR: c:@N@rdar14063074@ST>1#T@TS | lang: C++ | cursor: StructDecl=TS:10:8 (Definition) | loc: 10:8 | semantic-container: [r
[indexDeclaration]: kind: struct-template-spec | name: TS | USR: c:@N@rdar14063074@S@TS>#I | lang: C++ | cursor: StructDecl=TS:11:8 (Definition) [Specialization of TS:10:8] | loc: 1
[indexDeclaration]: kind: function-template | name: tfoo | USR: c:@N@rdar14063074@FT@>1#Ttfoo#v# | lang: C++ | cursor: FunctionDecl=tfoo:14:6 (Definition) | loc: 14:6 | semantic-con
[indexDeclaration]: kind: function-template-spec | name: tfoo | USR: c:@N@rdar14063074@F@tfoo<#I># | lang: C++ | cursor: FunctionDecl=tfoo:15:6 (Definition) [Specialization of tfoo:
[indexDeclaration]: kind: namespace | name: crash1 | USR: c:@N@crash1 | lang: C++ | cursor: Namespace=crash1:18:11 (Definition) | loc: 18:11 | semantic-container: [TU] | lexical-con
[indexDeclaration]: kind: c++-class-template | name: A | USR: c:@N@crash1@ST>1#T@A | lang: C++ | cursor: ClassDecl=A:19:28 (Definition) | loc: 19:28 | semantic-container: [crash1:18
[indexDeclaration]: kind: c++-instance-method | name: meth | USR: c:@N@crash1@ST>1#T@A@F@meth# | lang: C++ | cursor: CXXMethod=meth:21:8 | loc: 21:8 | semantic-container: [A:19:28] 
[indexDeclaration]: kind: c++-instance-method | name: meth | USR: c:@N@crash1@S@A>#I@F@meth# | lang: C++ | cursor: CXXMethod=meth:23:26 [Specialization of meth:21:8] | loc: 23:26 | 
[indexEntityReference]: kind: c++-class-template | name: A | USR: c:@N@crash1@ST>1#T@A | lang: C++ | cursor: TemplateRef=A:19:28 | loc: 23:18 | <parent>:: kind: c++-instance-method 
[indexDeclaration]: kind: c++-class | name: B | USR: c:@S@B | lang: C++ | cursor: ClassDecl=B:27:7 (Definition) | loc: 27:7 | semantic-container: [TU] | lexical-container: [TU] | is
[indexDeclaration]: kind: field | name: x_ | USR: c:@S@B@FI@x_ | lang: C++ | cursor: FieldDecl=x_:28:15 (Definition) (mutable) | loc: 28:15 | semantic-container: [B:27:7] | lexical-
[indexDeclaration]: kind: field | name: y_ | USR: c:@S@B@FI@y_ | lang: C++ | cursor: FieldDecl=y_:29:7 (Definition) | loc: 29:7 | semantic-container: [B:27:7] | lexical-container: [
[indexDeclaration]: kind: constructor | name: B | USR: c:@S@B@F@B# | lang: C++ | cursor: CXXConstructor=B:31:3 (default constructor) (defaulted) | loc: 31:3 | semantic-container: [B
[indexDeclaration]: kind: constructor | name: B | USR: c:@S@B@F@B#I# | lang: C++ | cursor: CXXConstructor=B:32:3 (converting constructor) | loc: 32:3 | semantic-container: [B:27:7] 
[indexDeclaration]: kind: constructor | name: B | USR: c:@S@B@F@B#d# | lang: C++ | cursor: CXXConstructor=B:33:12 | loc: 33:12 | semantic-container: [B:27:7] | lexical-container: [B
[indexDeclaration]: kind: constructor | name: B | USR: c:@S@B@F@B#&1$@S@B# | lang: C++ | cursor: CXXConstructor=B:34:3 (copy constructor) (converting constructor) | loc: 34:3 | sema
[indexEntityReference]: kind: c++-class | name: B | USR: c:@S@B | lang: C++ | cursor: TypeRef=class B:27:7 | loc: 34:11 | <parent>:: kind: constructor | name: B | USR: c:@S@B@F@B#&1
[indexDeclaration]: kind: constructor | name: B | USR: c:@S@B@F@B#&&$@S@B# | lang: C++ | cursor: CXXConstructor=B:35:3 (move constructor) (converting constructor) | loc: 35:3 | sema
[indexEntityReference]: kind: c++-class | name: B | USR: c:@S@B | lang: C++ | cursor: TypeRef=class B:27:7 | loc: 35:5 | <parent>:: kind: constructor | name: B | USR: c:@S@B@F@B#&&$
[indexDeclaration]: kind: c++-class | name: C | USR: c:@S@C | lang: C++ | cursor: ClassDecl=C:39:7 (Definition) | loc: 39:7 | semantic-container: [TU] | lexical-container: [TU] | is
[indexDeclaration]: kind: constructor | name: C | USR: c:@S@C@F@C#&1$@S@C# | lang: C++ | cursor: CXXConstructor=C:40:12 (copy constructor) | loc: 40:12 | semantic-container: [C:39:7
[indexEntityReference]: kind: c++-class | name: C | USR: c:@S@C | lang: C++ | cursor: TypeRef=class C:39:7 | loc: 40:20 | <parent>:: kind: constructor | name: C | USR: c:@S@C@F@C#&1
[diagnostic]: /Users/jon/DEV/llvm-git-svn/tools/clang/test/Index/index-file.cpp:1:21: warning: alias declarations are a C++11 extension [-Wc++11-extensions]
[diagnostic]: /Users/jon/DEV/llvm-git-svn/tools/clang/test/Index/index-file.cpp:4:28: error: C++ requires a type specifier for all declarations
[diagnostic]: /Users/jon/DEV/llvm-git-svn/tools/clang/test/Index/index-file.cpp:4:3: error: templates must have C++ linkage
[diagnostic]: /Users/jon/DEV/llvm-git-svn/tools/clang/test/Index/index-file.cpp:11:8: error: template specialization requires 'template<>'
[diagnostic]: /Users/jon/DEV/llvm-git-svn/tools/clang/test/Index/index-file.cpp:15:6: error: template specialization requires 'template<>'
[diagnostic]: /Users/jon/DEV/llvm-git-svn/tools/clang/test/Index/index-file.cpp:20:12: warning: deleted function definitions are a C++11 extension [-Wc++11-extensions]
[diagnostic]: /Users/jon/DEV/llvm-git-svn/tools/clang/test/Index/index-file.cpp:31:9: warning: defaulted function definitions are a C++11 extension [-Wc++11-extensions]
[diagnostic]: /Users/jon/DEV/llvm-git-svn/tools/clang/test/Index/index-file.cpp:35:6: warning: rvalue references are a C++11 extension [-Wc++11-extensions]
[diagnostic]: /Users/jon/DEV/llvm-git-svn/tools/clang/test/Index/index-file.cpp:36:16: warning: deleted function definitions are a C++11 extension [-Wc++11-extensions]

[jbcoe]

If I remove = delete from the declaration of the member function foo in test/Index/index-file.cpp line 36 then foo is reported in the output as

[indexDeclaration]: kind: c++-instance-method | name: foo | USR: c:@S@B@F@foo# | lang: C++ | cursor: CXXMethod=foo:36:8 | loc: 36:8 | semantic-container: [B:27:7] | lexical-container: [B:27:7] | isRedecl: 0 | isDef: 0 | isContainer: 0 | isImplicit: 0

with =delete in place, foo is not reported at all.

This is a behaviour change since I wrote this patch. I'm not sure what the correct behaviour should be. I can update the test and not check for the deleted function foo when we are confident that behaviour is correct.

The changed behaviour (not reporting deleted functions) is not part of my patch.

[skalinichev]

I see. There were some changes recently in the indexing functionality. I'm not sure whether this change is intended or not, but since it's not your fault and we already have a lot of tests confirming that clang_CXXMethod_isDeleted is working as expected (e.g. c-index-test -test-print-type) I think it's ok to remove this part of the test then

But just in case please open a bug report about skipped deleted methods with clangIndex.

tools/libclang/CIndex.cpp

7082

Just occurred to me: what about deleted "not member" functions? Maybe clang_CXXMethod_isDeleted should be renamed to something like clang_Cursor_isDeleted and there we can use FunctionDecl::isDeleted()

[jbcoe]

I plan to strip out the isDeleted methods as the associated tests now fail (which I need to raise a bug for) and need reworking to apply to non-member functions.

I'll submit a new patch for isDeleted on its own. The rest of this patch seems uncontentious.

I hope to find time this week to make the changes.

[jbcoe]

Remove isDeleted as it needs to be added for non-member functions.

I will add isDeleted as an isolated follow up patch.

[skalinichev]

LGTM!

bindings/python/tests/cindex/test_cursor.py

197

You should remove it too.

[jbcoe]

Remove python test for deleted method.

I missed this because the python tests are not run as part of check-clang - is this something I could submit a patch to change?

[mardy]

In D15469#396582, @jbcoe wrote:

I'll submit a new patch for isDeleted on its own. The rest of this patch seems uncontentious.

I hope to find time this week to make the changes.

Was the patch for isDeleted ever submitted? If not, I can try to get my hands dirty with it :-)

bindings/python/clang/cindex.py

         """
         return conf.lib.clang_CXXMethod_isConst(self)
 
+    def is_converting_constructor(self):
+        """Returns True if the cursor refers to a C++ converting constructor.
+        """
+        return conf.lib.clang_CXXConstructor_isConvertingConstructor(self)
+
+    def is_copy_constructor(self):
+        """Returns True if the cursor refers to a C++ copy constructor.
+        """
+        return conf.lib.clang_CXXConstructor_isCopyConstructor(self)
+
+    def is_default_constructor(self):
+        """Returns True if the cursor refers to a C++ default constructor.
+        """
+        return conf.lib.clang_CXXConstructor_isDefaultConstructor(self)
+
+    def is_move_constructor(self):
+        """Returns True if the cursor refers to a C++ move constructor.
+        """
+        return conf.lib.clang_CXXConstructor_isMoveConstructor(self)
+
+    def is_default_method(self):
+        """Returns True if the cursor refers to a C++ member function or member
+        function template that is declared '= default'.
+        """
+        return conf.lib.clang_CXXMethod_isDefaulted(self)
+
     def is_mutable_field(self):
         """Returns True if the cursor refers to a C++ field that is declared
         'mutable'.

    [Index, c_char_p],
    c_object_p),
 
+  ("clang_CXXConstructor_isConvertingConstructor",
+   [Cursor],
+   bool),
+
+  ("clang_CXXConstructor_isCopyConstructor",
+   [Cursor],
+   bool),
+
+  ("clang_CXXConstructor_isDefaultConstructor",
+   [Cursor],
+   bool),
+
+  ("clang_CXXConstructor_isMoveConstructor",
+   [Cursor],
+   bool),
+
   ("clang_CXXField_isMutable",
    [Cursor],
    bool),

    [Cursor],
    bool),
 
+  ("clang_CXXMethod_isDefaulted",
+   [Cursor],
+   bool),
+
   ("clang_CXXMethod_isPureVirtual",
    [Cursor],
    bool),

bindings/python/tests/cindex/test_cursor.py

     assert foo.is_const_method()
     assert not bar.is_const_method()
 
+def test_is_converting_constructor():
+    """Ensure Cursor.is_converting_constructor works."""
+    source = 'class X { explicit X(int); X(double); X(); };'
+    tu = get_tu(source, lang='cpp')
+
+    xs = get_cursors(tu, 'X')
+
+    assert len(xs) == 4
+    assert xs[0].kind == CursorKind.CLASS_DECL
+    cs = xs[1:]
+    assert cs[0].kind == CursorKind.CONSTRUCTOR
+    assert cs[1].kind == CursorKind.CONSTRUCTOR
+    assert cs[2].kind == CursorKind.CONSTRUCTOR
+
+    assert not cs[0].is_converting_constructor()
+    assert cs[1].is_converting_constructor()
+    assert not cs[2].is_converting_constructor()
+
+
+def test_is_copy_constructor():
+    """Ensure Cursor.is_copy_constructor works."""
+    source = 'class X { X(); X(const X&); X(X&&); };'
+    tu = get_tu(source, lang='cpp')
+
+    xs = get_cursors(tu, 'X')
+    assert xs[0].kind == CursorKind.CLASS_DECL
+    cs = xs[1:]
+    assert cs[0].kind == CursorKind.CONSTRUCTOR
+    assert cs[1].kind == CursorKind.CONSTRUCTOR
+    assert cs[2].kind == CursorKind.CONSTRUCTOR
+
+    assert not cs[0].is_copy_constructor()
+    assert cs[1].is_copy_constructor()
+    assert not cs[2].is_copy_constructor()
+
+def test_is_default_constructor():
+    """Ensure Cursor.is_default_constructor works."""
+    source = 'class X { X(); X(int); };'
+    tu = get_tu(source, lang='cpp')
+
+    xs = get_cursors(tu, 'X')
+    assert xs[0].kind == CursorKind.CLASS_DECL
+    cs = xs[1:]
+    assert cs[0].kind == CursorKind.CONSTRUCTOR
+    assert cs[1].kind == CursorKind.CONSTRUCTOR
+
+    assert cs[0].is_default_constructor()
+    assert not cs[1].is_default_constructor()
+
+def test_is_move_constructor():
+    """Ensure Cursor.is_move_constructor works."""
+    source = 'class X { X(); X(const X&); X(X&&); };'
+    tu = get_tu(source, lang='cpp')
+
+    xs = get_cursors(tu, 'X')
+    assert xs[0].kind == CursorKind.CLASS_DECL
+    cs = xs[1:]
+    assert cs[0].kind == CursorKind.CONSTRUCTOR
+    assert cs[1].kind == CursorKind.CONSTRUCTOR
+    assert cs[2].kind == CursorKind.CONSTRUCTOR
+
+    assert not cs[0].is_move_constructor()
+    assert not cs[1].is_move_constructor()
+    assert cs[2].is_move_constructor()
+
+def test_is_default_method():
+    """Ensure Cursor.is_default_method works."""
+    source = 'class X { X() = default; }; class Y { Y(); };'
+    tu = get_tu(source, lang='cpp')
+
+    xs = get_cursors(tu, 'X')
+    ys = get_cursors(tu, 'Y')
+
+    assert len(xs) == 2
+    assert len(ys) == 2
+
+    xc = xs[1]
+    yc = ys[1]
+
+    assert xc.is_default_method()
+    assert not yc.is_default_method()
+
+def test_is_deleted_method():
+    """Ensure Cursor.is_deleted_method works."""
+    source = 'class X { void foo() = delete; }; class Y { void bar(); };'
+    tu = get_tu(source, lang='cpp')
+
+    foo = get_cursor(tu, 'foo')
+    bar = get_cursor(tu, 'bar')
+
+    assert foo.is_deleted_method()
+    assert not bar.is_deleted_method()
+
 def test_is_mutable_field():
     """Ensure Cursor.is_mutable_field works."""
     source = 'class X { int x_; mutable int y_; };'

include/clang-c/Index.h

  */
 
 /**
+ * \brief Determine if a C++ constructor is a converting constructor.
+ */
+CINDEX_LINKAGE unsigned clang_CXXConstructor_isConvertingConstructor(CXCursor C);
+
+/**
+ * \brief Determine if a C++ constructor is a copy constructor.
+ */
+CINDEX_LINKAGE unsigned clang_CXXConstructor_isCopyConstructor(CXCursor C);
+
+/**
+ * \brief Determine if a C++ constructor is the default constructor.
+ */
+CINDEX_LINKAGE unsigned clang_CXXConstructor_isDefaultConstructor(CXCursor C);
+
+/**
+ * \brief Determine if a C++ constructor is a move constructor.
+ */
+CINDEX_LINKAGE unsigned clang_CXXConstructor_isMoveConstructor(CXCursor C);
+
+/**
  * \brief Determine if a C++ field is declared 'mutable'.
  */
 CINDEX_LINKAGE unsigned clang_CXXField_isMutable(CXCursor C);
 
 /**
+ * \brief Determine if a C++ method is declared '= default'.
+ */
+CINDEX_LINKAGE unsigned clang_CXXMethod_isDefaulted(CXCursor C);
+
+/**
  * \brief Determine if a C++ member function or member function template is
  * pure virtual.
  */

test/Index/availability.cpp

 // CHECK: FunctionDecl=foo:1:6 (unavailable) [type=void ()] [typekind=FunctionProto] [resulttype=void] [resulttypekind=Void] [isPOD=0]
 // CHECK: StructDecl=Foo:3:8 (Definition) [type=Foo] [typekind=Record] [isPOD=1]
 // CHECK: CXXMethod=foo:4:7 (unavailable) [type=int (){{.*}}] [typekind=FunctionProto] [resulttype=int] [resulttypekind=Int] [isPOD=0]
-// CHECK: CXXConstructor=Foo:5:3 (unavailable) [type=void (){{.*}}] [typekind=FunctionProto] [resulttype=void] [resulttypekind=Void] [isPOD=0]
+// CHECK: CXXConstructor=Foo:5:3 (unavailable) (default constructor) [type=void (){{.*}}] [typekind=FunctionProto] [resulttype=void] [resulttypekind=Void] [isPOD=0]

test/Index/file-refs.cpp

 // RUN:  -file-refs-at=%s:2:9 \
 // CHECK-NEXT: ClassDecl=C:2:9 (Definition)
 // CHECK-NEXT: ClassDecl=C:2:9 (Definition) =[2:9 - 2:10]
-// CHECK-NEXT: CXXConstructor=C:4:5 (Definition) =[4:5 - 4:6]
+// CHECK-NEXT: CXXConstructor=C:4:5 (Definition) (default constructor) =[4:5 - 4:6]
 // CHECK-NEXT: TypeRef=class NS::C:2:9 =[9:10 - 9:11]
 // CHECK-NEXT: TypeRef=class NS::C:2:9 =[10:3 - 10:4]
 // CHECK-NEXT: TypeRef=class NS::C:2:9 =[15:7 - 15:8]

 // RUN:  -file-refs-at=%s:16:18 \
 // CHECK-NEXT: CallExpr=C:4:5
 // CHECK-NEXT: ClassDecl=C:2:9 (Definition) =[2:9 - 2:10]
-// CHECK-NEXT: CXXConstructor=C:4:5 (Definition) =[4:5 - 4:6]
+// CHECK-NEXT: CXXConstructor=C:4:5 (Definition) (default constructor) =[4:5 - 4:6]
 // CHECK-NEXT: TypeRef=class NS::C:2:9 =[9:10 - 9:11]
 // CHECK-NEXT: TypeRef=class NS::C:2:9 =[10:3 - 10:4]
 // CHECK-NEXT: TypeRef=class NS::C:2:9 =[15:7 - 15:8]

 // CHECK-NEXT: CallExpr=S:35:3
 // CHECK-NEXT: StructDecl=S:34:8 (Definition) =[34:8 - 34:9]
 // CHECK-NEXT: CXXConstructor=S:35:3 =[35:3 - 35:4]
-// CHECK-NEXT: CXXConstructor=S:36:3 =[36:3 - 36:4]
+// CHECK-NEXT: CXXConstructor=S:36:3 (default constructor) =[36:3 - 36:4]
 // CHECK-NEXT: TypeRef=struct Test2::S:34:8 =[39:9 - 39:10]
 // CHECK-NEXT: TypeRef=struct Test2::S:34:8 =[43:14 - 43:15]
 

test/Index/get-cursor.cpp

 // CHECK-TEMPLSPEC: 66:23 ClassDecl=TC:66:23 (Definition) [Specialization of TC:59:7] Extent=[66:1 - 66:31] Spelling=TC ([66:23 - 66:25])
 
 // RUN: c-index-test -cursor-at=%s:69:3 -cursor-at=%s:70:11 -cursor-at=%s:73:6 -cursor-at=%s:74:6 -cursor-at=%s:77:8 -cursor-at=%s:78:8 -cursor-at=%s:79:8 -cursor-at=%s:80:8 -cursor-at=%s:81:8 -cursor-at=%s:82:8 -cursor-at=%s:85:6 -cursor-at=%s:86:6 -cursor-at=%s:87:6 -cursor-at=%s:88:6 -cursor-at=%s:91:5 -cursor-at=%s:92:5 -cursor-at=%s:93:5 -cursor-at=%s:94:5 -cursor-at=%s:95:5 -cursor-at=%s:96:5 -cursor-at=%s:97:5 -cursor-at=%s:98:5 -cursor-at=%s:100:5 -cursor-at=%s:101:5 -cursor-at=%s:104:6 -cursor-at=%s:105:6 -cursor-at=%s:106:6 -cursor-at=%s:107:6 -cursor-at=%s:108:6 -cursor-at=%s:109:6 -cursor-at=%s:110:6 -cursor-at=%s:111:6 -cursor-at=%s:113:6 -cursor-at=%s:114:6 -cursor-at=%s:117:8 -cursor-at=%s:118:8 -cursor-at=%s:120:8 -cursor-at=%s:121:8 -cursor-at=%s:122:8 -cursor-at=%s:123:8 -cursor-at=%s:124:8 -cursor-at=%s:125:8 -cursor-at=%s:128:6 -cursor-at=%s:129:6 -cursor-at=%s:130:6 -cursor-at=%s:132:3 -std=c++11 %s | FileCheck -check-prefix=CHECK-SPELLING %s
-// CHECK-SPELLING: 69:3 CXXConstructor=A:69:3 Extent=[69:3 - 69:6] Spelling=A ([69:3 - 69:4])
+// CHECK-SPELLING: 69:3 CXXConstructor=A:69:3 (default constructor) Extent=[69:3 - 69:6] Spelling=A ([69:3 - 69:4])
 // CHECK-SPELLING: 70:11 CXXDestructor=~A:70:11 (virtual) Extent=[70:3 - 70:15] Spelling=~A ([70:11 - 70:13])
 // CHECK-SPELLING: 73:6 CXXMethod=operator=:73:6 Extent=[73:3 - 73:25] Spelling=operator= ([73:6 - 73:15])
 // CHECK-SPELLING: 74:6 CXXMethod=operator=:74:6 Extent=[74:3 - 74:29] Spelling=operator= ([74:6 - 74:15])

test/Index/index-file.cpp

 class B {
   mutable int x_;
   int y_;
+
+  B() = default;
+  B(int);
+  explicit B(double);
+  B(const B&);
+  B(B&&);
+};
+
+class C {
+  explicit C(const C&);
 };
+
 // RUN: c-index-test -index-file %s > %t
 // RUN: FileCheck %s -input-file=%t
 

 // CHECK: [indexDeclaration]: kind: c++-instance-method | name: meth | {{.*}} | loc: 23:26
 // CHECK: [indexDeclaration]: kind: field | name: x_ | USR: c:@S@B@FI@x_ | lang: C++ | cursor: FieldDecl=x_:28:15 (Definition) (mutable) | loc: 28:15 | semantic-container: [B:27:7] | lexical-container: [B:27:7] | isRedecl: 0 | isDef: 1 | isContainer: 0 | isImplicit: 0
 // CHECK: [indexDeclaration]: kind: field | name: y_ | USR: c:@S@B@FI@y_ | lang: C++ | cursor: FieldDecl=y_:29:7 (Definition) | loc: 29:7 | semantic-container: [B:27:7] | lexical-container: [B:27:7] | isRedecl: 0 | isDef: 1 | isContainer: 0 | isImplicit: 0
+// CHECK: [indexDeclaration]: kind: constructor | name: B | {{.*}} (default constructor) (defaulted) | loc: 31:3
+// CHECK: [indexDeclaration]: kind: constructor | name: B | {{.*}} (converting constructor) | loc: 32:3
+// CHECK: [indexDeclaration]: kind: constructor | name: B | {{.*}} | loc: 33:12
+// CHECK: [indexDeclaration]: kind: constructor | name: B | {{.*}} (copy constructor) (converting constructor) | loc: 34:3
+// CHECK: [indexDeclaration]: kind: constructor | name: B | {{.*}} (move constructor) (converting constructor) | loc: 35:3
+// CHECK: [indexDeclaration]: kind: constructor | name: C | {{.*}} (copy constructor) | loc: 39:12

test/Index/load-classes.cpp

 
 // 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 - 21:2]
-// CHECK: load-classes.cpp:4:3: CXXConstructor=X:4:3 Extent=[4:3 - 4:15] [access=public]
+// 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 Extent=[5:3 - 5:16] [access=public]
+// 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:16:21: TemplateTypeParameter=T:16:21 (Definition) Extent=[16:12 - 16:22] [access=public]
 // CHECK: load-classes.cpp:19:16: CXXMethod=virtualMemberFunction:19:16 (virtual) Extent=[19:3 - 19:39] [access=private]
 // CHECK: load-classes.cpp:20:16: CXXMethod=pureVirtualMemberFunction:20:16 (virtual) (pure) Extent=[20:3 - 20:47] [access=private]
-// CHECK: load-classes.cpp:23:4: CXXConstructor=X:23:4 (Definition) Extent=[23:1 - 24:2] [access=public]
+// CHECK: load-classes.cpp:23:4: CXXConstructor=X:23:4 (Definition) (converting constructor) Extent=[23:1 - 24:2] [access=public]
 // CHECK: load-classes.cpp:23:1: TypeRef=struct X:3:8 Extent=[23:1 - 23:2]
 // CHECK: load-classes.cpp:23:10: ParmDecl=value:23:10 (Definition) Extent=[23:6 - 23:15]
 // CHECK: load-classes.cpp:23:17: CompoundStmt= Extent=[23:17 - 24:2]

test/Index/print-type.cpp

 // CHECK: TemplateTemplateParameter=W:8:60 (Definition) [type=] [typekind=Invalid] [isPOD=0]
 // CHECK: Namespace=inner:14:11 (Definition) [type=] [typekind=Invalid] [isPOD=0]
 // CHECK: StructDecl=Bar:16:8 (Definition) [type=outer::inner::Bar] [typekind=Record] [isPOD=0] [nbFields=3]
-// CHECK: CXXConstructor=Bar:17:3 (Definition) [type=void (outer::Foo<bool> *){{.*}}] [typekind=FunctionProto] [canonicaltype=void (outer::Foo<bool> *){{.*}}] [canonicaltypekind=FunctionProto] [resulttype=void] [resulttypekind=Void] [args= [outer::Foo<bool> *] [Pointer]] [isPOD=0]
+// CHECK: CXXConstructor=Bar:17:3 (Definition) (converting constructor) [type=void (outer::Foo<bool> *){{.*}}] [typekind=FunctionProto] [canonicaltype=void (outer::Foo<bool> *){{.*}}] [canonicaltypekind=FunctionProto] [resulttype=void] [resulttypekind=Void] [args= [outer::Foo<bool> *] [Pointer]] [isPOD=0]
 // CHECK: ParmDecl=foo:17:25 (Definition) [type=outer::Foo<bool> *] [typekind=Pointer] [canonicaltype=outer::Foo<bool> *] [canonicaltypekind=Pointer] [isPOD=1] [pointeetype=outer::Foo<bool>] [pointeekind=Unexposed]
 // CHECK: NamespaceRef=outer:1:11 [type=] [typekind=Invalid] [isPOD=0]
 // CHECK: TemplateRef=Foo:4:8 [type=] [typekind=Invalid] [isPOD=0]

test/Index/recursive-cxx-member-calls.cpp

 // CHECK: 45:58: DeclRefExpr=a:45:28 Extent=[45:58 - 45:59]
 // CHECK: 45:62: DeclRefExpr=b:45:38 Extent=[45:62 - 45:63]
 // CHECK: 46:1: CXXAccessSpecifier=:46:1 (Definition) Extent=[46:1 - 46:8]
-// CHECK: 47:3: CXXConstructor=StringRef:47:3 (Definition) Extent=[47:3 - 47:37]
+// CHECK: 47:3: CXXConstructor=StringRef:47:3 (Definition) (default constructor) Extent=[47:3 - 47:37]
 // CHECK: 47:16: MemberRef=Data:43:15 Extent=[47:16 - 47:20]
 // CHECK: 47:21: UnexposedExpr= Extent=[47:21 - 47:22]
 // CHECK: 47:21: IntegerLiteral= Extent=[47:21 - 47:22]

 // CHECK: 47:32: UnexposedExpr= Extent=[47:32 - 47:33]
 // CHECK: 47:32: IntegerLiteral= Extent=[47:32 - 47:33]
 // CHECK: 47:35: CompoundStmt= Extent=[47:35 - 47:37]
-// CHECK: 48:3: CXXConstructor=StringRef:48:3 (Definition) Extent=[48:3 - 48:71]
+// CHECK: 48:3: CXXConstructor=StringRef:48:3 (Definition) (converting constructor) Extent=[48:3 - 48:71]
 // CHECK: 48:25: ParmDecl=Str:48:25 (Definition) Extent=[48:13 - 48:28]
 // CHECK: 48:32: MemberRef=Data:43:15 Extent=[48:32 - 48:36]
 // CHECK: 48:37: DeclRefExpr=Str:48:25 Extent=[48:37 - 48:40]

 // CHECK: 65:11: Namespace=clang:65:11 (Definition) Extent=[65:1 - 81:2]
 // CHECK: 66:7: ClassDecl=IdentifierInfo:66:7 (Definition) Extent=[66:1 - 80:2]
 // CHECK: 67:1: CXXAccessSpecifier=:67:1 (Definition) Extent=[67:1 - 67:8]
-// CHECK: 67:8: CXXConstructor=IdentifierInfo:67:8 Extent=[67:8 - 67:24]
+// CHECK: 67:8: CXXConstructor=IdentifierInfo:67:8 (default constructor) Extent=[67:8 - 67:24]
 // CHECK: 68:15: CXXMethod=getNameStart:68:15 (Definition) (const) Extent=[68:3 - 71:4] [access=public]
 // CHECK: 68:36: CompoundStmt= Extent=[68:36 - 71:4]
 // CHECK: 69:5: DeclStmt= Extent=[69:5 - 69:65]

test/Parser/skip-function-bodies.mm

 // CHECK: skip-function-bodies.mm:3:7: ClassDecl=A:3:7 (Definition) Extent=[3:1 - 14:2]
 // CHECK: skip-function-bodies.mm:4:9: ClassDecl=B:4:9 (Definition) Extent=[4:3 - 4:13]
 // CHECK: skip-function-bodies.mm:6:1: CXXAccessSpecifier=:6:1 (Definition) Extent=[6:1 - 6:8]
-// CHECK: skip-function-bodies.mm:7:3: CXXConstructor=A:7:3 Extent=[7:3 - 7:6]
+// CHECK: skip-function-bodies.mm:7:3: CXXConstructor=A:7:3 (default constructor) Extent=[7:3 - 7:6]
 // CHECK-NOT: skip-function-bodies.mm:8:12: StructDecl=C:8:12 (Definition) Extent=[8:5 - 10:6]
 // CHECK-NOT: skip-function-bodies.mm:9:12: CXXMethod=d:9:12 (Definition) Extent=[9:7 - 9:18]
 // CHECK: skip-function-bodies.mm:13:13: TypedefDecl=E:13:13 (Definition) Extent=[13:3 - 13:14]

tools/c-index-test/c-index-test.c

     
     clang_disposeString(DeprecatedMessage);
     clang_disposeString(UnavailableMessage);
-    
+    if (clang_CXXConstructor_isDefaultConstructor(Cursor))
+      printf(" (default constructor)");
+
+    if (clang_CXXConstructor_isMoveConstructor(Cursor))
+      printf(" (move constructor)");
+    if (clang_CXXConstructor_isCopyConstructor(Cursor))
+      printf(" (copy constructor)");
+    if (clang_CXXConstructor_isConvertingConstructor(Cursor))
+      printf(" (converting constructor)");
     if (clang_CXXField_isMutable(Cursor))
       printf(" (mutable)");
+    if (clang_CXXMethod_isDefaulted(Cursor))
+      printf(" (defaulted)");
     if (clang_CXXMethod_isStatic(Cursor))
       printf(" (static)");
     if (clang_CXXMethod_isVirtual(Cursor))

tools/libclang/CIndex.cpp

 //===----------------------------------------------------------------------===//
 
 extern "C" {
+
+unsigned clang_CXXConstructor_isDefaultConstructor(CXCursor C) {
+  if (!clang_isDeclaration(C.kind))
+    return 0;
+
+  const Decl *D = cxcursor::getCursorDecl(C);
+  const CXXConstructorDecl *Constructor =
+      D ? dyn_cast_or_null<CXXConstructorDecl>(D->getAsFunction()) : nullptr;
+  return (Constructor && Constructor->isDefaultConstructor()) ? 1 : 0;
+}
+
+unsigned clang_CXXConstructor_isCopyConstructor(CXCursor C) {
+  if (!clang_isDeclaration(C.kind))
+    return 0;
+
+  const Decl *D = cxcursor::getCursorDecl(C);
+  const CXXConstructorDecl *Constructor =
+      D ? dyn_cast_or_null<CXXConstructorDecl>(D->getAsFunction()) : nullptr;
+  return (Constructor && Constructor->isCopyConstructor()) ? 1 : 0;
+}
+
+unsigned clang_CXXConstructor_isMoveConstructor(CXCursor C) {
+  if (!clang_isDeclaration(C.kind))
+    return 0;
+
+  const Decl *D = cxcursor::getCursorDecl(C);
+  const CXXConstructorDecl *Constructor =
+      D ? dyn_cast_or_null<CXXConstructorDecl>(D->getAsFunction()) : nullptr;
+  return (Constructor && Constructor->isMoveConstructor()) ? 1 : 0;
+}
+
+unsigned clang_CXXConstructor_isConvertingConstructor(CXCursor C) {
+  if (!clang_isDeclaration(C.kind))
+    return 0;
+
+  const Decl *D = cxcursor::getCursorDecl(C);
+  const CXXConstructorDecl *Constructor =
+      D ? dyn_cast_or_null<CXXConstructorDecl>(D->getAsFunction()) : nullptr;
+  // Passing 'false' excludes constructors marked 'explicit'.
+  return (Constructor && Constructor->isConvertingConstructor(false)) ? 1 : 0;
+}
+
 unsigned clang_CXXField_isMutable(CXCursor C) {
   if (!clang_isDeclaration(C.kind))
     return 0;

   return (Method && (Method->getTypeQualifiers() & Qualifiers::Const)) ? 1 : 0;
 }
 
+unsigned clang_CXXMethod_isDefaulted(CXCursor C) {
+  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->isDefaulted()) ? 1 : 0;
+}
+
 unsigned clang_CXXMethod_isStatic(CXCursor C) {
   if (!clang_isDeclaration(C.kind))
     return 0;

tools/libclang/libclang.exports

 clang_CXCursorSet_insert
 clang_CXIndex_getGlobalOptions
 clang_CXIndex_setGlobalOptions
+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