Add HasTypeQualifier and RemoveTypeQualifier

Author: Vipul-Cariappa

include/clang/Interpreter/CppInterOp.h

@@ -88,6 +88,12 @@ namespace Cpp {
 
   enum OperatorArity { kUnary = 1, kBinary, kBoth };
 
+  enum Qualifier : unsigned {
+    Const = 0b01,
+    Volatile = 0b010,
+    Restrict = 0b0100
+  };
+
   /// A class modeling function calls for functions produced by the interpreter
   /// in compiled code. It provides an information if we are calling a standard
   /// function, constructor or destructor.
@@ -253,6 +259,14 @@ namespace Cpp {
   /// Checks if the passed value is an enum type or not.
   CPPINTEROP_API bool IsEnumType(TCppType_t type);
 
+  /// Checks if the passed type has qual Qualifiers
+  /// qual can be ORed value of enum Qualifier
+  CPPINTEROP_API bool HasTypeQualifier(TCppType_t type, unsigned qual);
+
+  /// Returns type with the qual Qualifiers
+  /// qual can be ORed value of enum Qualifier
+  CPPINTEROP_API TCppType_t RemoveTypeQualifier(TCppType_t type, unsigned qual);
+
   /// Extracts enum declarations from a specified scope and stores them in
   /// vector
   CPPINTEROP_API void GetEnums(TCppScope_t scope,

lib/Interpreter/CppInterOp.cpp

@@ -1657,6 +1657,40 @@ namespace Cpp {
     return QT.getCanonicalType().getAsOpaquePtr();
   }
 
+  bool HasTypeQualifier(TCppType_t type, unsigned qual) {
+    if (!type)
+      return false;
+
+    QualType QT = QualType::getFromOpaquePtr(type);
+    if (qual & Qualifier::Const) {
+      if (!QT.isConstQualified())
+        return false;
+    }
+    if (qual & Qualifier::Volatile) {
+      if (!QT.isVolatileQualified())
+        return false;
+    }
+    if (qual & Qualifier::Restrict) {
+      if (!QT.isRestrictQualified())
+        return false;
+    }
+    return true;
+  }
+
+  TCppType_t RemoveTypeQualifier(TCppType_t type, unsigned qual) {
+    if (!type)
+      return type;
+
+    auto QT = QualType(QualType::getFromOpaquePtr(type));
+    if (qual & Qualifier::Const)
+      QT.removeLocalConst();
+    if (qual & Qualifier::Volatile)
+      QT.removeLocalVolatile();
+    if (qual & Qualifier::Restrict)
+      QT.removeLocalRestrict();
+    return QT.getAsOpaquePtr();
+  }
+
   // Internal functions that are not needed outside the library are
   // encompassed in an anonymous namespace as follows. This function converts
   // from a string to the actual type. It is used in the GetType() function.

unittests/CppInterOp/TypeReflectionTest.cpp

@@ -610,3 +610,61 @@ TEST(TypeReflectionTest, IsFunctionPointerType) {
   EXPECT_FALSE(
       Cpp::IsFunctionPointerType(Cpp::GetVariableType(Cpp::GetNamed("i"))));
 }
+
+TEST(TypeReflectionTest, TypeQualifiers) {
+  Cpp::CreateInterpreter();
+  Cpp::Declare(R"(
+    int *a;
+    int *__restrict b;
+    int *const c = 0;
+    int *volatile d;
+    int *const volatile e = nullptr;
+    int *__restrict const f = nullptr;
+    int *__restrict volatile g;
+    int *__restrict const volatile h = nullptr;
+  )");
+
+  Cpp::TCppType_t a = Cpp::GetVariableType(Cpp::GetNamed("a"));
+  Cpp::TCppType_t b = Cpp::GetVariableType(Cpp::GetNamed("b"));
+  Cpp::TCppType_t c = Cpp::GetVariableType(Cpp::GetNamed("c"));
+  Cpp::TCppType_t d = Cpp::GetVariableType(Cpp::GetNamed("d"));
+  Cpp::TCppType_t e = Cpp::GetVariableType(Cpp::GetNamed("e"));
+  Cpp::TCppType_t f = Cpp::GetVariableType(Cpp::GetNamed("f"));
+  Cpp::TCppType_t g = Cpp::GetVariableType(Cpp::GetNamed("g"));
+  Cpp::TCppType_t h = Cpp::GetVariableType(Cpp::GetNamed("h"));
+
+  EXPECT_FALSE(Cpp::HasTypeQualifier(nullptr, 0));
+  EXPECT_FALSE(Cpp::RemoveTypeQualifier(nullptr, 0));
+
+  EXPECT_FALSE(Cpp::HasTypeQualifier(a, Cpp::Qualifier::Const));
+  EXPECT_FALSE(Cpp::HasTypeQualifier(a, Cpp::Qualifier::Volatile));
+  EXPECT_FALSE(Cpp::HasTypeQualifier(a, Cpp::Qualifier::Restrict));
+  EXPECT_TRUE(Cpp::HasTypeQualifier(b, Cpp::Qualifier::Restrict));
+  EXPECT_TRUE(Cpp::HasTypeQualifier(c, Cpp::Qualifier::Const));
+  EXPECT_TRUE(Cpp::HasTypeQualifier(d, Cpp::Qualifier::Volatile));
+  EXPECT_TRUE(Cpp::HasTypeQualifier(e, Cpp::Qualifier::Const |
+                                           Cpp::Qualifier::Volatile));
+  EXPECT_TRUE(Cpp::HasTypeQualifier(f, Cpp::Qualifier::Const |
+                                           Cpp::Qualifier::Restrict));
+  EXPECT_TRUE(Cpp::HasTypeQualifier(g, Cpp::Qualifier::Volatile |
+                                           Cpp::Qualifier::Restrict));
+  EXPECT_TRUE(Cpp::HasTypeQualifier(h, Cpp::Qualifier::Const |
+                                           Cpp::Qualifier::Volatile |
+                                           Cpp::Qualifier::Restrict));
+
+  EXPECT_EQ(a, Cpp::RemoveTypeQualifier(b, Cpp::Qualifier::Restrict));
+  EXPECT_EQ(a, Cpp::RemoveTypeQualifier(c, Cpp::Qualifier::Const));
+  EXPECT_EQ(a, Cpp::RemoveTypeQualifier(d, Cpp::Qualifier::Volatile));
+  EXPECT_EQ(a, Cpp::RemoveTypeQualifier(e, Cpp::Qualifier::Const |
+                                               Cpp::Qualifier::Volatile));
+  EXPECT_EQ(a, Cpp::RemoveTypeQualifier(f, Cpp::Qualifier::Const |
+                                               Cpp::Qualifier::Restrict));
+  EXPECT_EQ(a, Cpp::RemoveTypeQualifier(g, Cpp::Qualifier::Volatile |
+                                               Cpp::Qualifier::Restrict));
+  EXPECT_EQ(a, Cpp::RemoveTypeQualifier(h, Cpp::Qualifier::Const |
+                                               Cpp::Qualifier::Volatile |
+                                               Cpp::Qualifier::Restrict));
+  EXPECT_EQ(e, Cpp::RemoveTypeQualifier(h, Cpp::Qualifier::Restrict));
+  EXPECT_EQ(b, Cpp::RemoveTypeQualifier(h, Cpp::Qualifier::Const |
+                                               Cpp::Qualifier::Volatile));
+}