Expose QualType::getUnqualifiedType in libclang

[diseraluca]

Summary

The method is now wrapped by clang_getUnqualifiedType.

A declaration for clang_getUnqualifiedType was added to
clang-c/Index.h to expose it to user of the library.

An implementation for clang_getUnqualifiedType was introduced in
CXType.cpp that wraps the equivalent method of the underlying
QualType of a CXType.

An export symbol was added to libclang.map under the new version entry
LLVM_16.

A test was added to LibclangTest.cpp that tests the removal of
qualifiers for some CXTypes.

[diseraluca]

I recently encountered a few cases, at work, as an employee of The Qt Company, where we would have liked to have access to getUnqualifiedType in libclang.

I found a precedence on the old mailing list, from 2018 (https://lists.llvm.org/pipermail/cfe-dev/2018-February/056874.html), for a similar request, where it seemed it wouldn't be disruptive to expose it to libclang.

This is my first contribution to llvm-project, so I apologize if I missed some requirement or pushed a patch that is incorrect.
I'm obviously open to spend more time on this patch if there is something that should be modified.

Originally the patch contained the addition of clang_getNonReferenceType too, as that is something else that we would like to have access to.
I avoided including it into this patch because:

• As I understand it, having both in one patch would not comply with the isolated changes requirement in https://www.llvm.org/docs/Contributing.html#how-to-submit-a-patch.
• I could not find any precedence for requesting that specific interface and am unsure if the correct etiquette requires that a discussion is opened BEFORE pushing this kind of patch.
• First pushing a smaller patch would allow me to get accustomed to the contributing workflow and understand what I might have done incorrectly, so as to push an higher quality patch.

Any clarification on if a patch that exposes getNonReferencedType requires a discussion to be opened before being pushed for acceptance and review is appreciated.

[aaron.ballman]

In D132749#3752233, @diseraluca wrote:

I found a precedence on the old mailing list, from 2018 (https://lists.llvm.org/pipermail/cfe-dev/2018-February/056874.html), for a similar request, where it seemed it wouldn't be disruptive to expose it to libclang.

Yup! FWIW, we will add things to libclang as people say they found a need for them (we do similar for AST matchers). We mostly just want to avoid trying to expose all of the APIs through a C interface, as that causes significant maintenance burden given how rapidly our APIs change.

This is my first contribution to llvm-project, so I apologize if I missed some requirement or pushed a patch that is incorrect.
I'm obviously open to spend more time on this patch if there is something that should be modified.

Welcome to the community!

Originally the patch contained the addition of clang_getNonReferenceType too, as that is something else that we would like to have access to.

That seems perfectly reasonable to me as well.

I avoided including it into this patch because:

• As I understand it, having both in one patch would not comply with the isolated changes requirement in https://www.llvm.org/docs/Contributing.html#how-to-submit-a-patch.
• I could not find any precedence for requesting that specific interface and am unsure if the correct etiquette requires that a discussion is opened BEFORE pushing this kind of patch.
• First pushing a smaller patch would allow me to get accustomed to the contributing workflow and understand what I might have done incorrectly, so as to push an higher quality patch.

Any clarification on if a patch that exposes getNonReferencedType requires a discussion to be opened before being pushed for acceptance and review is appreciated.

Feel free to put up a new review for that and add me as a reviewer, I'm happy to look at it. It should be a separate patch because we like to keep patches logically separate in case we need to revert something (no sense in losing all the good changes along with the bad by sticking them all in one patch). It's also far easier to review a patch without a lot of moving parts to it.

In terms of this patch, it looks good to me, but can you add a release note for the improvement? (We have a section for libclang that this should go under.) Once you post the patch with the release note, I'm happy to land this on your behalf (assuming precommit CI doesn't find any surprises I missed). What name and email address would you like used for patch attribution?

[diseraluca]

Added a note to the release-notes.

[diseraluca]

Welcome to the community!

Thank you for the kind welcome!

Feel free to put up a new review for that and add me as a reviewer, I'm happy to look at it

Thank you, I'll be sure to do that.

In terms of this patch, it looks good to me, but can you add a release note for the improvement?

This should be done now.

What name and email address would you like used for patch attribution?

Name: Luca Di Sera
email: disera [dot] luca [at] gmail [dot] com

Is there a way for me to configure this so that it is picked up automatically?

[tbaeder]

clang/include/clang-c/Index.h

3775

Typo: Unuqualified

3779

Same

3792

Typo: Volative

[diseraluca]

Fixed some typos in the added documentation of clang_getUnqualifiedType.

clang/docs/ReleaseNotes.rst

 ------------
 
 clang-extdef-mapping
 --------------------
 
 libclang
 --------
 
-- ...
+- Introduced the new function `clang_getUnqualifiedType`, which mimics
+  the behavior of `QualType::getUnqualifiedType` for `CXType`.
 
 Static Analyzer
 ---------------
 
 - Removed the deprecated ``-analyzer-store`` and
   ``-analyzer-opt-analyze-nested-blocks`` analyzer flags.
   ``scanbuild`` was also updated accordingly.
   Passing these flags will result in a hard error.

clang/include/clang-c/Index.h

 CINDEX_LINKAGE CXString clang_getTypedefName(CXType CT);
 
 /**
  * For pointer types, returns the type of the pointee.
  */
 CINDEX_LINKAGE CXType clang_getPointeeType(CXType T);
 
 /**
+ * Retrieve the unqualified variant of the given type, removing as
+ * little sugar as possible.
+ *
+ * For example, given the following series of typedefs:
+ *
+ * \code
+ * typedef int Integer;
+ * typedef const Integer CInteger;
+ * typedef CInteger DifferenceType;
+ * \endcode
+ *
+ * Executing \c clang_getUnqualifiedType() on a \c CXType that
+ * represents \c DifferenceType, will desugar to a type representing
+ * \c Integer, that has no qualifiers.
+ *
+ * And, executing \c clang_getUnqualifiedType() on the type of the
+ * first argument of the following function declaration:
+ *
+ * \code
+ * void foo(const int);
+ * \endcode
+ *
+ * Will return a type representing \c int, removing the \c const
+ * qualifier.
+ *
+ * Sugar over array types is not desugared.
+ *
+ * A type can be checked for qualifiers with \c
+ * clang_isConstQualifiedType(), \c clang_isVolatileQualifiedType()
+ * and \c clang_isRestrictQualifiedType().
+ *
+ * A type that resulted from a call to \c clang_getUnqualifiedType
+ * will return \c false for all of the above calls.
+ */
+CINDEX_LINKAGE CXType clang_getUnqualifiedType(CXType CT);
+
+/**
  * Return the cursor for the declaration of the given type.
  */
 CINDEX_LINKAGE CXCursor clang_getTypeDeclaration(CXType T);
 
 /**
  * Returns the Objective-C type encoding for the specified declaration.
  */
 CINDEX_LINKAGE CXString clang_getDeclObjCTypeEncoding(CXCursor C);

clang/tools/libclang/CXType.cpp

case Type::DeducedTemplateSpecialization:
       break;
     default:
       T = QualType();
       break;
   }
   return MakeCXType(T, GetTU(CT));
 }
 
+CXType clang_getUnqualifiedType(CXType CT) {
+  return MakeCXType(GetQualType(CT).getUnqualifiedType(), GetTU(CT));
+}
+
 CXCursor clang_getTypeDeclaration(CXType CT) {
   if (CT.kind == CXType_Invalid)
     return cxcursor::MakeCXCursorInvalid(CXCursor_NoDeclFound);
 
   QualType T = GetQualType(CT);
   const Type *TP = T.getTypePtrOrNull();
 
   if (!TP)

clang/tools/libclang/libclang.map

global:
     clang_tokenize;
     clang_uninstall_llvm_fatal_error_handler;
     clang_visitChildren;
     clang_visitChildrenWithBlock;
 
   local: *;
 };
 
+LLVM_16 {
+  global:
+    clang_getUnqualifiedType;
+};
+
 # 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;
 # };

clang/unittests/libclang/LibclangTest.cpp

clang_visitChildren(
         if (clang_getCursorKind(cursor) == CXCursor_VarDecl) {
           EXPECT_TRUE(clang_Cursor_hasVarDeclExternalStorage(cursor));
           return CXChildVisit_Break;
         }
         return CXChildVisit_Continue;
       },
       nullptr);
 }
+
+TEST_F(LibclangParseTest, clang_getUnqualifiedTypeRemovesQualifiers) {
+  std::string Header = "header.h";
+  WriteFile(Header, "void foo1(const int);\n"
+                    "void foo2(volatile int);\n"
+                    "void foo3(const volatile int);\n"
+                    "void foo4(int* const);\n"
+                    "void foo5(int* volatile);\n"
+                    "void foo6(int* restrict);\n"
+                    "void foo7(int* const volatile);\n"
+                    "void foo8(int* volatile restrict);\n"
+                    "void foo9(int* const restrict);\n"
+                    "void foo10(int* const volatile restrict);\n");
+
+  auto is_qualified = [](CXType type) -> bool {
+    return clang_isConstQualifiedType(type) ||
+           clang_isVolatileQualifiedType(type) ||
+           clang_isRestrictQualifiedType(type);
+  };
+
+  auto from_CXString = [](CXString cx_string) -> std::string {
+    std::string string{clang_getCString(cx_string)};
+
+    clang_disposeString(cx_string);
+
+    return string;
+  };
+
+  ClangTU = clang_parseTranslationUnit(Index, Header.c_str(), nullptr, 0,
+                                       nullptr, 0, TUFlags);
+
+  Traverse([&is_qualified, &from_CXString](CXCursor cursor, CXCursor) {
+    if (clang_getCursorKind(cursor) == CXCursor_FunctionDecl) {
+      CXType arg_type = clang_getArgType(clang_getCursorType(cursor), 0);
+      EXPECT_TRUE(is_qualified(arg_type))
+          << "Input data '" << from_CXString(clang_getCursorSpelling(cursor))
+          << "' first argument does not have a qualified type.";
+
+      CXType unqualified_arg_type = clang_getUnqualifiedType(arg_type);
+      EXPECT_FALSE(is_qualified(unqualified_arg_type))
+          << "The type '" << from_CXString(clang_getTypeSpelling(arg_type))
+          << "' was not unqualified after a call to clang_getUnqualifiedType.";
+    }
+
+    return CXChildVisit_Continue;
+  });
+}
+
 class LibclangRewriteTest : public LibclangParseTest {
 public:
   CXRewriter Rew = nullptr;
   std::string Filename;
   CXFile File = nullptr;
 
   void SetUp() override {
     LibclangParseTest::SetUp();