Add clang_CXXMethod_isExplicit to libclang

[diseraluca]

Summary

The new method is a wrapper of CXXConstructorDecl::isExplicit and
CXXConversionDecl::isExplicit, allowing the user to recognize whether
the declaration pointed to by a cursor was marked with the explicit
specifier.

An export for the function, together with its documentation, was added
to "clang/include/clang-c/Index.h" with an implementation provided in
"clang/tools/libclang/CIndex.cpp".

The implementation is based on similar clang_CXXMethod
implementations, returning a falsy unsigned value when the cursor is not
a declaration, is not a declaration for a constructor or conversion
function or is not a relevant declaration that was marked with the
explicit specifier.

The new symbol was added to "clang/tools/libclang/libclang.map" to be
exported, under the LLVM16 tag.

"clang/tools/c-index-test/c-index-test.c" was modified to print a
specific tag, "(explicit)", for cursors that are recognized by
clang_CXXMethod_isExplicit.

Two new regression files, "explicit-constructor.cpp" and
"explicit-conversion-function.cpp", were added to "clang/test/Index", to
ensure that the behavior of the new function is correct for constructors
and conversion functions, respectively.

The "get-cursor.cpp", "index-file.cpp" and
"recursive-cxx-member-calls.cpp" regression files in "clang/test/Index"
were updated as they were affected by the new "(explicit)" tag.

A binding for the new function was added to libclang's python's
bindings, in "clang/bindings/python/clang/cindex.py", as the
"is_explicit_method" method under Cursor.

An accompanying test was added to
"clang/bindings/python/tests/cindex/test_cursor.py", mimicking the
regression tests for the C side.

The current release note for Clang, "clang/docs/ReleaseNotes.rst" was
modified to report the new addition under the "libclang" section.

[aaron.ballman]

LGTM aside from some minor things you can correct when landing.

clang/bindings/python/clang/cindex.py

1550–1557

You might want to add documentation about:

constexpr bool foo(int i) { return i % 2 == 0; }

struct S {
  explicit(foo(1)) S(); // IsExplicit returns false
  explicit(foo(2)) operator int(); // IsExplicit returns true

so it's not about the syntactic element of there being an explicit, it's about what it resolves to.

clang/include/clang-c/Index.h

4364

Same doc suggestions around here as in the Python code.

clang/tools/libclang/CIndex.cpp

8955–8961

Same logic, but spelled differently.

[diseraluca]

In D140756#4051383, @aaron.ballman wrote:

LGTM aside from some minor things you can correct when landing.
....

Thank you for the great suggestions!

I'll try to correct it as soon as possible, hopefully this weekend.
Should I update the revision or should I just modify it and land it after ensuring that it works correctly?

[aaron.ballman]

In D140756#4055516, @diseraluca wrote:

In D140756#4051383, @aaron.ballman wrote:

LGTM aside from some minor things you can correct when landing.
....

Thank you for the great suggestions!

I'll try to correct it as soon as possible, hopefully this weekend.
Should I update the revision or should I just modify it and land it after ensuring that it works correctly?

Thanks for checking! Feel free to modify it and land it after ensuring it works correctly. :-)

[diseraluca]

When I pushed the patch the tests produced failures in buildbot.
I reverted the patch as I did not have the time to check what was happening.

I've now had time to check and the failures seems to be due to the implementation dependent signed-ness of char,
thus failing on platforms where char is unsigned (like power pc).

I've changed the tests to use a more precise unsigned char which should solve the issue.
There is probably a way to only check for the presence or lack thereof of the (explicit) tag without checking those unimportant details,
but I had not time to accustom myself to FileCheck yet.

I reopened the revision to have a second set of eyes check this as I would really like to avoid blocking the integrations again.

[diseraluca]

Fixed tests

[aaron.ballman]

The fixes LGTM, thank you!

[vedgy]

Hello Luca and Aaron.
I have noticed that you recently implemented/reviewed multiple interesting libclang features, some of which can be used in KDevelop. However, CINDEX_VERSION_MINOR was last modified in Clang 13. This constant's documentation states:

CINDEX_VERSION_MINOR should increase when there are API additions.

Can this constant be incremented in the upcoming Clang 16 release?

[aaron.ballman]

In D140756#4099326, @vedgy wrote:

Hello Luca and Aaron.
I have noticed that you recently implemented/reviewed multiple interesting libclang features, some of which can be used in KDevelop. However, CINDEX_VERSION_MINOR was last modified in Clang 13. This constant's documentation states:

CINDEX_VERSION_MINOR should increase when there are API additions.

Can this constant be incremented in the upcoming Clang 16 release?

That's a great catch, yes it can. I'll post a patch today to bump it on trunk and then file an issue to cherry-pick it over to the 16.x branch. Thank you!

[aaron.ballman]

In D140756#4099410, @aaron.ballman wrote:

In D140756#4099326, @vedgy wrote:

Hello Luca and Aaron.
I have noticed that you recently implemented/reviewed multiple interesting libclang features, some of which can be used in KDevelop. However, CINDEX_VERSION_MINOR was last modified in Clang 13. This constant's documentation states:

CINDEX_VERSION_MINOR should increase when there are API additions.

Can this constant be incremented in the upcoming Clang 16 release?

That's a great catch, yes it can. I'll post a patch today to bump it on trunk and then file an issue to cherry-pick it over to the 16.x branch. Thank you!

79571aa2103c95760a07e3549d8636379e4948f0 is the commit on main and https://github.com/llvm/llvm-project/issues/60478 is for the 16.x cherry-pick.

[vedgy]

79571aa2103c95760a07e3549d8636379e4948f0 is the commit on main and https://github.com/llvm/llvm-project/issues/60478 is for the 16.x cherry-pick.

Thank you Aaron! But note that this review's commit ended up in Clang 17, not Clang 16. Previous API additions have been implemented earlier and are included in Clang 16.

[aaron.ballman]

In D140756#4099558, @vedgy wrote:

79571aa2103c95760a07e3549d8636379e4948f0 is the commit on main and https://github.com/llvm/llvm-project/issues/60478 is for the 16.x cherry-pick.

Thank you Aaron! But note that this review's commit ended up in Clang 17, not Clang 16. Previous API additions have been implemented earlier and are included in Clang 16.

Yup, that's why I opened up the issue to backport it into Clang 16. We don't usually make edits directly to the branch, instead we put them on main and cherry-pick them over to the release branch. Our cherry-picking bot is doing the work (you can see it adding comments to https://github.com/llvm/llvm-project/issues/60478).

[vedgy]

I meant that the commit message of https://reviews.llvm.org/rG79571aa2103c95760a07e3549d8636379e4948f0 misleadingly refers to this review's commit. But CINDEX_VERSION_MINOR == 63 is for previous commits. This commit will require incrementing CINDEX_VERSION_MINOR again to 64 in Clang 17. Hopefully my preamble-storage patches will also be included in Clang 17 and share the same minor version 64 :)

[aaron.ballman]

In D140756#4099593, @vedgy wrote:

I meant that the commit message of https://reviews.llvm.org/rG79571aa2103c95760a07e3549d8636379e4948f0 misleadingly refers to this review's commit. But CINDEX_VERSION_MINOR == 63 is for previous commits. This commit will require incrementing CINDEX_VERSION_MINOR again to 64 in Clang 17. Hopefully my preamble-storage patches will also be included in Clang 17 and share the same minor version 64 :)

Hmmm, I thought 0a51bc731bcc2c27e4fe97957a83642d93d989be landed before we did the branch (and so was the last change in Clang 16) and we don't have any new CIndex commits since then to bump it to 64 (yet). However, now I see that it almost made the branch but was reverted https://github.com/llvm/llvm-project/commit/1af716499d6bc29afd9ff2903200890df774859f (though we had other changes in Clang 16 justifying the version bump, such as 5c67cf0a7fdc00c9b9c55578b770e768f5618bed).

So I think you're right, we need one more commit on main to bump to 64 because of 0a51bc731bcc2c27e4fe97957a83642d93d989be. And yes, I think the preamble storage patches will be in Clang 17 and share the same minor version.

[vedgy]

clang/tools/libclang/libclang.map

419

This line should be moved from under the LLVM_16 tag to under a new LLVM_17 tag. Alternatively this commit can be cherry-picked into the LLVM 16 branch.

[aaron.ballman]

@diseraluca -- do you need this cherry picked into Clang 16 or are you fine if this goes into Clang 17 instead?

[vedgy]

The added, then reverted release note was lost when this revision landed the second time.

[aaron.ballman]

In D140756#4100387, @aaron.ballman wrote:

@diseraluca -- do you need this cherry picked into Clang 16 or are you fine if this goes into Clang 17 instead?

I'll go with the assumption this is fine going into Clang 17 and not needing to be cherry-picked. I'll take care of that and the missed release note when I have a spare moment. (Thanks @vedgy for noticing these changes are needed!)

[aaron.ballman]

In D140756#4115363, @aaron.ballman wrote:

In D140756#4100387, @aaron.ballman wrote:

@diseraluca -- do you need this cherry picked into Clang 16 or are you fine if this goes into Clang 17 instead?

I'll go with the assumption this is fine going into Clang 17 and not needing to be cherry-picked. I'll take care of that and the missed release note when I have a spare moment. (Thanks @vedgy for noticing these changes are needed!)

The spare moment came sooner than expected, I've made the changes in de4321cf2cf28f2bae7fc0f1897957e73b726f89.

[vedgy]

In D140756#4115381, @aaron.ballman wrote:

The spare moment came sooner than expected, I've made the changes in de4321cf2cf28f2bae7fc0f1897957e73b726f89.

Isn't the global: label needed in the new LLVM_17 block/tag?

[aaron.ballman]

In D140756#4115963, @vedgy wrote:

In D140756#4115381, @aaron.ballman wrote:

The spare moment came sooner than expected, I've made the changes in de4321cf2cf28f2bae7fc0f1897957e73b726f89.

Isn't the global: label needed in the new LLVM_17 block/tag?

I thought that was the default already, but I see the others do it explicitly, so I will as well.

[aaron.ballman]

In D140756#4115979, @aaron.ballman wrote:

In D140756#4115963, @vedgy wrote:

In D140756#4115381, @aaron.ballman wrote:

The spare moment came sooner than expected, I've made the changes in de4321cf2cf28f2bae7fc0f1897957e73b726f89.

Isn't the global: label needed in the new LLVM_17 block/tag?

I thought that was the default already, but I see the others do it explicitly, so I will as well.

Added in 4c84c1314716392061215aac7f299493bdf3cc93

[diseraluca]

In D140756#4100387, @aaron.ballman wrote:

@diseraluca -- do you need this cherry picked into Clang 16 or are you fine if this goes into Clang 17 instead?

Sorry for checking in so late, I noticed the notifications only now. We are using a different solution for the time being so it is correct that this is fine being in Clang 17.

Thank you for taking care of this.

[aaron.ballman]

In D140756#4128729, @diseraluca wrote:

In D140756#4100387, @aaron.ballman wrote:

@diseraluca -- do you need this cherry picked into Clang 16 or are you fine if this goes into Clang 17 instead?

Sorry for checking in so late, I noticed the notifications only now. We are using a different solution for the time being so it is correct that this is fine being in Clang 17.

Thank you for taking care of this.

Thank you for the info!

clang/bindings/python/clang/cindex.py

def is_move_assignment_operator_method(self):
            class Bar {
                bool operator=(const int&&);
            };
 
         Is not.
         """
         return conf.lib.clang_CXXMethod_isMoveAssignmentOperator(self)
 
+    def is_explicit_method(self):
+        """Determines if a C++ constructor or conversion function is
+        explicit, returning 1 if such is the case and 0 otherwise.
+
+        Constructors or conversion functions are declared explicit through
+        the use of the explicit specifier.
+
+        For example, the following constructor and conversion function are
+        not explicit as they lack the explicit specifier:
+
+            class Foo {
+                Foo();
+                operator int();
+            };
+
+        While the following constructor and conversion function are
+        explicit as they are declared with the explicit specifier.
+
+            class Foo {
+                explicit Foo();
+                explicit operator int();
+            };
+
+        This method will return 0 when given a cursor pointing to one of
+        the former declarations and it will return 1 for a cursor pointing
+        to the latter declarations.
+
+        The explicit specifier allows the user to specify a
+        conditional compile-time expression whose value decides
+        whether the marked element is explicit or not.
+
+        For example:
+
+            constexpr bool foo(int i) { return i % 2 == 0; }
+
+            class Foo {
+                 explicit(foo(1)) Foo();
+                 explicit(foo(2)) operator int();
+            }
+
+        This method will return 0 for the constructor and 1 for
+        the conversion function.
+        """
+        return conf.lib.clang_CXXMethod_isExplicit(self)
+
     def is_mutable_field(self):
         """Returns True if the cursor refers to a C++ field that is declared
         'mutable'.
         """
         return conf.lib.clang_CXXField_isMutable(self)
 
     def is_pure_virtual_method(self):
         """Returns True if the cursor refers to a C++ member function or member
functionList = [
   ("clang_CXXMethod_isCopyAssignmentOperator",
    [Cursor],
    bool),
 
   ("clang_CXXMethod_isMoveAssignmentOperator",
    [Cursor],
    bool),
 
+  ("clang_CXXMethod_isExplicit",
+   [Cursor],
+   bool),
+
   ("clang_CXXMethod_isPureVirtual",
    [Cursor],
    bool),
 
   ("clang_CXXMethod_isStatic",
    [Cursor],
    bool),
 

clang/bindings/python/tests/cindex/test_cursor.py

def test_is_move_assignment_operator_method(self):
             cursor.is_move_assignment_operator_method()
             for cursor in move_assignment_operators_cursors
         ]))
         self.assertFalse(any([
             cursor.is_move_assignment_operator_method()
             for cursor in non_move_assignment_operators_cursors
         ]))
 
+    def test_is_explicit_method(self):
+        """Ensure Cursor.is_explicit_method works."""
+        source_with_explicit_methods = """
+        struct Foo {
+           // Those are explicit
+           explicit Foo(double);
+           explicit(true) Foo(char);
+           explicit operator double();
+           explicit(true) operator char();
+        };
+        """
+        source_without_explicit_methods = """
+        struct Foo {
+            // Those are not explicit
+            Foo(int);
+            explicit(false) Foo(float);
+            operator int();
+            explicit(false) operator float();
+        };
+        """
+        tu_with_explicit_methods = get_tu(
+            source_with_explicit_methods, lang="cpp"
+        )
+        tu_without_explicit_methods = get_tu(
+            source_without_explicit_methods, lang="cpp"
+        )
+
+        explicit_methods_cursors = [
+            *get_cursors(tu_with_explicit_methods, "Foo")[1:],
+            get_cursor(tu_with_explicit_methods, "operator double"),
+            get_cursor(tu_with_explicit_methods, "operator char"),
+        ]
+
+        non_explicit_methods_cursors = [
+            *get_cursors(tu_without_explicit_methods, "Foo")[1:],
+            get_cursor(tu_without_explicit_methods, "operator int"),
+            get_cursor(tu_without_explicit_methods, "operator float"),
+        ]
+
+        self.assertEqual(len(explicit_methods_cursors), 4)
+        self.assertTrue(len(non_explicit_methods_cursors), 4)
+
+        self.assertTrue(all([
+            cursor.is_explicit_method()
+            for cursor in explicit_methods_cursors
+        ]))
+        self.assertFalse(any([
+            cursor.is_explicit_method()
+            for cursor in non_explicit_methods_cursors
+        ]))
+
     def test_is_mutable_field(self):
         """Ensure Cursor.is_mutable_field works."""
         source = 'class X { int x_; mutable int y_; };'
         tu = get_tu(source, lang='cpp')
 
         cls = get_cursor(tu, 'X')
         x_ = get_cursor(tu, 'x_')
         y_ = get_cursor(tu, 'y_')

clang/include/clang-c/Index.h

  *        bool operator=(const int&&);
  *    };
  *
  * Is not.
  */
 CINDEX_LINKAGE unsigned clang_CXXMethod_isMoveAssignmentOperator(CXCursor C);
 
 /**
+ * Determines if a C++ constructor or conversion function was declared
+ * explicit, returning 1 if such is the case and 0 otherwise.
+ *
+ * Constructors or conversion functions are declared explicit through
+ * the use of the explicit specifier.
+ *
+ * For example, the following constructor and conversion function are
+ * not explicit as they lack the explicit specifier:
+ *
+ *     class Foo {
+ *         Foo();
+ *         operator int();
+ *     };
+ *
+ * While the following constructor and conversion function are
+ * explicit as they are declared with the explicit specifier.
+ *
+ *     class Foo {
+ *         explicit Foo();
+ *         explicit operator int();
+ *     };
+ *
+ * This function will return 0 when given a cursor pointing to one of
+ * the former declarations and it will return 1 for a cursor pointing
+ * to the latter declarations.
+ *
+ * The explicit specifier allows the user to specify a
+ * conditional compile-time expression whose value decides
+ * whether the marked element is explicit or not.
+ *
+ * For example:
+ *
+ *     constexpr bool foo(int i) { return i % 2 == 0; }
+ *
+ *     class Foo {
+ *          explicit(foo(1)) Foo();
+ *          explicit(foo(2)) operator int();
+ *     }
+ *
+ * This function will return 0 for the constructor and 1 for
+ * the conversion function.
+ */
+CINDEX_LINKAGE unsigned clang_CXXMethod_isExplicit(CXCursor C);
+
+/**
  * 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);
 
 /**
  * Determine if an enum declaration refers to a scoped enum.
  */

clang/test/Index/explicit-constructor.cpp

+struct Foo {
+    // Those are not explicit constructors
+    Foo(int);
+    explicit(false) Foo(float);
+
+    // Those are explicit constructors
+    explicit Foo(double);
+    explicit(true) Foo(unsigned char);
+};
+
+// RUN: c-index-test -test-print-type --std=c++20 %s | FileCheck %s
+// CHECK: StructDecl=Foo:1:8 (Definition) [type=Foo] [typekind=Record] [isPOD=0]
+// CHECK: CXXConstructor=Foo:3:5 (converting constructor) [type=void (int)] [typekind=FunctionProto] [resulttype=void] [resulttypekind=Void] [args= [int] [Int]] [isPOD=0] [isAnonRecDecl=0]
+// CHECK: CXXConstructor=Foo:4:21 (converting constructor) [type=void (float)] [typekind=FunctionProto] [resulttype=void] [resulttypekind=Void] [args= [float] [Float]] [isPOD=0] [isAnonRecDecl=0]
+// CXXConstructor=Foo:7:20 (explicit) [type=void (double)] [typekind=FunctionProto] [resulttype=void] [resulttypekind=Void] [args= [double] [Double]] [isPOD=0] [isAnonRecDecl=0]
+// CXXConstructor=Foo:8:20 (explicit) [type=void (unsigned char)] [typekind=FunctionProto] [resulttype=void] [resulttypekind=Void] [args= [unsigned char] [UChar]] [isPOD=0] [isAnonRecDecl=0]

clang/test/Index/explicit-conversion-function.cpp

+struct Foo {
+    // Those are not explicit conversion functions
+    operator int();
+    explicit(false) operator float();
+
+    // Those are explicit conversion functions
+    explicit operator double();
+    explicit(true) operator unsigned char();
+};
+
+// RUN: c-index-test -test-print-type --std=c++20 %s | FileCheck %s
+// CHECK: StructDecl=Foo:1:8 (Definition) [type=Foo] [typekind=Record]
+// CHECK: CXXConversion=operator int:3:5 [type=int ()] [typekind=FunctionProto] [resulttype=int] [resulttypekind=Int] [isPOD=0] [isAnonRecDecl=0]
+// CHECK: CXXConversion=operator float:4:21 [type=float ()] [typekind=FunctionProto] [resulttype=float] [resulttypekind=Float] [isPOD=0] [isAnonRecDecl=0]
+// CHECK: CXXConversion=operator double:7:14 (explicit) [type=double ()] [typekind=FunctionProto] [resulttype=double] [resulttypekind=Double] [isPOD=0] [isAnonRecDecl=0]
+// CHECK: CXXConversion=operator unsigned char:8:20 (explicit) [type=unsigned char ()] [typekind=FunctionProto] [resulttype=unsigned char] [resulttypekind=UChar] [isPOD=0] [isAnonRecDecl=0]

clang/test/Index/get-cursor.cpp

 // CHECK-SPELLING: 121:8 CXXMethod=operator||:121:8 (const) Extent=[121:3 - 121:34] Spelling=operator|| ([121:8 - 121:18])
 // CHECK-SPELLING: 122:8 CXXMethod=operator<=:122:8 (const) Extent=[122:3 - 122:34] Spelling=operator<= ([122:8 - 122:18])
 // CHECK-SPELLING: 123:8 CXXMethod=operator>=:123:8 (const) Extent=[123:3 - 123:34] Spelling=operator>= ([123:8 - 123:18])
 // CHECK-SPELLING: 124:8 CXXMethod=operator!=:124:8 (const) Extent=[124:3 - 124:34] Spelling=operator!= ([124:8 - 124:18])
 // CHECK-SPELLING: 125:8 CXXMethod=operator==:125:8 (const) Extent=[125:3 - 125:34] Spelling=operator== ([125:8 - 125:18])
 // CHECK-SPELLING: 128:6 CXXMethod=operator[]:128:6 Extent=[128:3 - 128:36] Spelling=operator[] ([128:6 - 128:16])
 // CHECK-SPELLING: 129:6 CXXMethod=operator->:129:6 Extent=[129:3 - 129:18] Spelling=operator-> ([129:6 - 129:16])
 // CHECK-SPELLING: 130:6 CXXMethod=operator():130:6 (const) Extent=[130:3 - 130:37] Spelling=operator() ([130:6 - 130:16])
-// CHECK-SPELLING: 132:12 CXXConversion=operator bool:132:12 (const) Extent=[132:3 - 132:33] Spelling=operator bool ([132:12 - 132:25])
+// CHECK-SPELLING: 132:12 CXXConversion=operator bool:132:12 (const) (explicit) Extent=[132:3 - 132:33] Spelling=operator bool ([132:12 - 132:25])
 // CHECK-SPELLING: 146:11 FunctionDecl=operator""_toint:146:11 (Definition) Extent=[146:1 - 146:72] Spelling=operator""_toint ([146:11 - 146:27])
 // CHECK-SPELLING: 149:6 FunctionDecl=f_noexcept:149:6 (noexcept) Extent=[149:1 - 149:27] Spelling=f_noexcept ([149:6 - 149:16])
 // CHECK-SPELLING: 150:25 FunctionTemplate=f_computed_noexcept:150:25 (computed-noexcept) Extent=[150:1 - 150:73] Spelling=f_computed_noexcept ([150:25 - 150:44])
 // CHECK-SPELLING: 151:6 FunctionDecl=f_dynamic_noexcept_none:151:6 (noexcept dynamic none) Extent=[151:1 - 151:39] Spelling=f_dynamic_noexcept_none ([151:6 - 151:29])
 // CHECK-SPELLING: 152:6 FunctionDecl=f_dynamic_noexcept:152:6 (noexcept dynamic) Extent=[152:1 - 152:37] Spelling=f_dynamic_noexcept ([152:6 - 152:24])
 // CHECK-SPELLING: 153:6 FunctionDecl=f_dynamic_noexcept_any:153:6 (noexcept dynamic any) Extent=[153:1 - 153:41] Spelling=f_dynamic_noexcept_any ([153:6 - 153:28])
 // CHECK-SPELLING: 154:6 FunctionDecl=f_computed_noexcept_true:154:6 (computed-noexcept) Extent=[154:1 - 154:47] Spelling=f_computed_noexcept_true ([154:6 - 154:30])
 // CHECK-SPELLING: 155:6 FunctionDecl=f_computed_noexcept_false:155:6 (computed-noexcept) Extent=[155:1 - 155:49] Spelling=f_computed_noexcept_false ([155:6 - 155:31])

clang/test/Index/index-file.cpp

 // 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
+// CHECK: [indexDeclaration]: kind: constructor | name: C | {{.*}} (copy constructor) (explicit) | loc: 39:12

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

 // CHECK-tokens: Keyword: "const" [85:3 - 85:8] FieldDecl=Result:85:12 (Definition)
 // CHECK-tokens: Identifier: "T" [85:9 - 85:10] TypeRef=T:83:21
 // CHECK-tokens: Punctuation: "*" [85:11 - 85:12] FieldDecl=Result:85:12 (Definition)
 // CHECK-tokens: Identifier: "Result" [85:12 - 85:18] FieldDecl=Result:85:12 (Definition)
 // CHECK-tokens: Punctuation: ";" [85:18 - 85:19] ClassTemplate=StringSwitch:83:47 (Definition)
 // CHECK-tokens: Keyword: "public" [86:1 - 86:7] CXXAccessSpecifier=:86:1 (Definition)
 // CHECK-tokens: Punctuation: ":" [86:7 - 86:8] CXXAccessSpecifier=:86:1 (Definition)
 // CHECK-tokens: Keyword: "explicit" [87:3 - 87:11] CXXConstructor=StringSwitch<T, R>:87:12 (Definition)
-// CHECK-tokens: Identifier: "StringSwitch" [87:12 - 87:24] CXXConstructor=StringSwitch<T, R>:87:12 (Definition)
+// CHECK-tokens: Identifier: "StringSwitch" [87:12 - 87:24] CXXConstructor=StringSwitch<T, R>:87:12 (Definition) (explicit)
 // CHECK-tokens: Punctuation: "(" [87:24 - 87:25] CXXConstructor=StringSwitch<T, R>:87:12 (Definition)
 // CHECK-tokens: Identifier: "StringRef" [87:25 - 87:34] TypeRef=class llvm::StringRef:38:7
 // CHECK-tokens: Identifier: "Str" [87:35 - 87:38] ParmDecl=Str:87:35 (Definition)
 // CHECK-tokens: Punctuation: ")" [87:38 - 87:39] CXXConstructor=StringSwitch<T, R>:87:12 (Definition)
 // CHECK-tokens: Punctuation: ":" [87:40 - 87:41] CXXConstructor=StringSwitch<T, R>:87:12 (Definition)
 // CHECK-tokens: Identifier: "Str" [87:42 - 87:45] MemberRef=Str:84:13
 // CHECK-tokens: Punctuation: "(" [87:45 - 87:46] CallExpr=StringRef:38:7
 // CHECK-tokens: Identifier: "Str" [87:46 - 87:49] DeclRefExpr=Str:87:35

 // CHECK: 82:11: Namespace=llvm:82:11 (Definition) Extent=[82:1 - 96:2]
 // CHECK: 83:47: ClassTemplate=StringSwitch:83:47 (Definition) Extent=[83:1 - 95:2]
 // CHECK: 83:21: TemplateTypeParameter=T:83:21 (Definition) Extent=[83:12 - 83:22]
 // CHECK: 83:33: TemplateTypeParameter=R:83:33 (Definition) Extent=[83:24 - 83:38]
 // CHECK: 84:13: FieldDecl=Str:84:13 (Definition) Extent=[84:3 - 84:16]
 // CHECK: 84:3: TypeRef=class llvm::StringRef:38:7 Extent=[84:3 - 84:12]
 // CHECK: 85:12: FieldDecl=Result:85:12 (Definition) Extent=[85:3 - 85:18]
 // CHECK: 86:1: CXXAccessSpecifier=:86:1 (Definition) Extent=[86:1 - 86:8]
-// CHECK: 87:12: CXXConstructor=StringSwitch<T, R>:87:12 (Definition) Extent=[87:3 - 87:64]
+// CHECK: 87:12: CXXConstructor=StringSwitch<T, R>:87:12 (Definition) (explicit) Extent=[87:3 - 87:64]
 // CHECK: 87:35: ParmDecl=Str:87:35 (Definition) Extent=[87:25 - 87:38]
 // CHECK: 87:25: TypeRef=class llvm::StringRef:38:7 Extent=[87:25 - 87:34]
 // CHECK: 87:42: MemberRef=Str:84:13 Extent=[87:42 - 87:45]
 // CHECK: 87:42: CallExpr=StringRef:38:7 Extent=[87:42 - 87:50]
 // CHECK: 87:46: DeclRefExpr=Str:87:35 Extent=[87:46 - 87:49]
 // CHECK: 87:52: MemberRef=Result:85:12 Extent=[87:52 - 87:58]
 // CHECK: 87:58: UnexposedExpr= Extent=[87:58 - 87:61]
 // CHECK: 87:59: IntegerLiteral= Extent=[87:59 - 87:60]

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

else {
     if (clang_CXXMethod_isConst(Cursor))
       printf(" (const)");
     if (clang_CXXMethod_isPureVirtual(Cursor))
       printf(" (pure)");
     if (clang_CXXMethod_isCopyAssignmentOperator(Cursor))
       printf(" (copy-assignment operator)");
     if (clang_CXXMethod_isMoveAssignmentOperator(Cursor))
       printf(" (move-assignment operator)");
+    if (clang_CXXMethod_isExplicit(Cursor))
+      printf(" (explicit)");
     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)");

clang/tools/libclang/CIndex.cpp

unsigned clang_CXXMethod_isMoveAssignmentOperator(CXCursor C) {
 
   const Decl *D = cxcursor::getCursorDecl(C);
   const CXXMethodDecl *Method =
       D ? dyn_cast_or_null<CXXMethodDecl>(D->getAsFunction()) : nullptr;
 
   return (Method && Method->isMoveAssignmentOperator()) ? 1 : 0;
 }
 
+unsigned clang_CXXMethod_isExplicit(CXCursor C) {
+  if (!clang_isDeclaration(C.kind))
+    return 0;
+
+  const Decl *D = cxcursor::getCursorDecl(C);
+  const FunctionDecl *FD = D->getAsFunction();
+
+  if (!FD)
+    return 0;
+
+  if (const auto *Ctor = dyn_cast<CXXConstructorDecl>(FD))
+    return Ctor->isExplicit();
+
+  if (const auto *Conv = dyn_cast<CXXConversionDecl>(FD))
+    return Conv->isExplicit();
+
+  return 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();

clang/tools/libclang/libclang.map

global:
     clang_getNonReferenceType;
     clang_CXXMethod_isDeleted;
     clang_CXXMethod_isCopyAssignmentOperator;
     clang_CXXMethod_isMoveAssignmentOperator;
     clang_createAPISet;
     clang_disposeAPISet;
     clang_getSymbolGraphForCursor;
     clang_getSymbolGraphForUSR;
+    clang_CXXMethod_isExplicit;
 };
 
 # Example of how to add a new symbol version entry.  If you do add a new symbol
 # version, please update the example to depend on the version you added.
 # LLVM_X {
 # global:
 #   clang_newsymbol;
 # };