Add type info interfaces motivated by numba

include/clang/Interpreter/CppInterOp.h

@@ -509,15 +509,40 @@ namespace Cpp {
   /// Checks if the provided parameter is a Plain Old Data Type (POD).
   CPPINTEROP_API bool IsPODType(TCppType_t type);
 
+  /// Checks if type has an integer representation
+  CPPINTEROP_API bool IsIntegerType(TCppType_t type);
+
+  /// Checks if type is an integral type
+  CPPINTEROP_API bool IsIntegralType(TCppType_t type);
+
+  /// Checks if type is a signed integer
+  CPPINTEROP_API bool IsSignedIntegerType(TCppType_t type);
+
+  /// Checks if type has an unsigned integer
+  CPPINTEROP_API bool IsUnsignedIntegerType(TCppType_t type);
+
+  /// Checks if type has a floating representation
+  CPPINTEROP_API bool IsFloatingType(TCppType_t type);
+
+  /// Checks if two types are the equivalent
+  /// i.e. have the same canonical type
+  CPPINTEROP_API bool IsSameType(TCppType_t type_a, TCppType_t type_b);
+
   /// Checks if type is a pointer
   CPPINTEROP_API bool IsPointerType(TCppType_t type);
 
+  /// Checks if type is a void pointer
+  CPPINTEROP_API bool IsVoidPointerType(TCppType_t type);
+
   /// Get the underlying pointee type
   CPPINTEROP_API TCppType_t GetPointeeType(TCppType_t type);
 
   /// Checks if type is a reference
   CPPINTEROP_API bool IsReferenceType(TCppType_t type);
 
+  /// Get the type handle to the unqualified type
+  CPPINTEROP_API TCppType_t GetUnqualifiedType(TCppType_t type);
+
   /// Get the type that the reference refers to
   CPPINTEROP_API TCppType_t GetNonReferenceType(TCppType_t type);
 

lib/Interpreter/CppInterOp.cpp

@@ -1549,11 +1549,47 @@ namespace Cpp {
     return QT.isPODType(getASTContext());
   }
 
+  bool IsIntegerType(TCppType_t type) {
+    QualType QT = QualType::getFromOpaquePtr(type);
+    return QT->hasIntegerRepresentation();
+  }
+
+  bool IsIntegralType(TCppType_t type) {
+    QualType QT = QualType::getFromOpaquePtr(type);
+    return QT->isIntegralType(getASTContext());
+  }
+
+  bool IsSignedIntegerType(TCppType_t type) {
+    QualType QT = QualType::getFromOpaquePtr(type);
+    return QT->hasSignedIntegerRepresentation();
+  }
+
+  bool IsUnsignedIntegerType(TCppType_t type) {
+    QualType QT = QualType::getFromOpaquePtr(type);
+    return QT->hasUnsignedIntegerRepresentation();
+  }
+
+  bool IsFloatingType(TCppType_t type) {
+    QualType QT = QualType::getFromOpaquePtr(type);
+    return QT->hasFloatingRepresentation();
+  }
+
+  bool IsSameType(TCppType_t type_a, TCppType_t type_b) {
+    clang::QualType QT1 = clang::QualType::getFromOpaquePtr(type_a);
+    clang::QualType QT2 = clang::QualType::getFromOpaquePtr(type_b);
+    return getASTContext().hasSameType(QT1, QT2);
+  }
+
   bool IsPointerType(TCppType_t type) {
     QualType QT = QualType::getFromOpaquePtr(type);
     return QT->isPointerType();
   }
 
+  bool IsVoidPointerType(TCppType_t type) {
+    QualType QT = QualType::getFromOpaquePtr(type);
+    return QT->isVoidPointerType();
+  }
+
   TCppType_t GetPointeeType(TCppType_t type) {
     if (!IsPointerType(type))
       return nullptr;
@@ -1573,8 +1609,17 @@ namespace Cpp {
     return QT.getNonReferenceType().getAsOpaquePtr();
   }
 
+  TCppType_t GetUnqualifiedType(TCppType_t type) {
+    if (!type)
+      return nullptr;
+    QualType QT = QualType::getFromOpaquePtr(type);
+    return QT.getUnqualifiedType().getAsOpaquePtr();
+  }
+
   TCppType_t GetUnderlyingType(TCppType_t type)
   {
+    if (!type)
+      return nullptr;
     QualType QT = QualType::getFromOpaquePtr(type);
     QT = QT->getCanonicalTypeUnqualified();
 

unittests/CppInterOp/TypeReflectionTest.cpp

@@ -600,3 +600,127 @@ TEST(TypeReflectionTest, IsFunctionPointerType) {
   EXPECT_FALSE(
       Cpp::IsFunctionPointerType(Cpp::GetVariableType(Cpp::GetNamed("i"))));
 }
+
+TEST(TypeReflectionTest, IntegerTypes) {
+  Cpp::CreateInterpreter();
+  std::vector<Decl*> Decls;
+  std::string code = R"(
+  int a;
+  int *b;
+  double c;
+  enum A { x, y };
+  A evar = x;
+  char k;
+  long int l;
+  unsigned int m;
+  unsigned long n;
+  )";
+
+  GetAllTopLevelDecls(code, Decls);
+
+  EXPECT_TRUE(Cpp::IsIntegerType(Cpp::GetVariableType(Decls[0])));
+  EXPECT_FALSE(Cpp::IsIntegerType(Cpp::GetVariableType(Decls[1])));
+  EXPECT_FALSE(Cpp::IsIntegerType(Cpp::GetVariableType(Decls[2])));
+  EXPECT_TRUE(Cpp::IsIntegerType(Cpp::GetVariableType(Decls[4])));
+  EXPECT_TRUE(Cpp::IsIntegralType(Cpp::GetVariableType(Decls[5])));
+  EXPECT_TRUE(Cpp::IsIntegralType(Cpp::GetVariableType(Decls[6])));
+  EXPECT_TRUE(Cpp::IsUnsignedIntegerType(Cpp::GetVariableType(Decls[7])));
+  EXPECT_FALSE(Cpp::IsSignedIntegerType(Cpp::GetVariableType(Decls[8])));
+}
+
+TEST(TypeReflectionTest, VoidPtrType) {
+  Cpp::CreateInterpreter();
+  std::vector<Decl*> Decls;
+  std::string code = R"(
+  class A {};
+  using VoidPtrType = void*;
+  VoidPtrType a = nullptr;
+  void * b = nullptr;
+  A *pa = nullptr;
+  )";
+
+  GetAllTopLevelDecls(code, Decls);
+
+  EXPECT_EQ(Cpp::GetTypeAsString(Cpp::GetVariableType(Decls[2])), "VoidPtrType");
+  EXPECT_TRUE(Cpp::IsVoidPointerType(Cpp::GetVariableType(Decls[2])));
+  EXPECT_TRUE(Cpp::IsVoidPointerType(Cpp::GetVariableType(Decls[3])));
+  EXPECT_FALSE(Cpp::IsVoidPointerType(Cpp::GetVariableType(Decls[4])));
+}
+
+TEST(TypeReflectionTest, IsSameType) {
+  Cpp::CreateInterpreter();
+  std::vector<Decl*> Decls;
+
+  std::string code = R"(
+    #include <cstdarg>
+    #include <iostream>
+
+    typedef std::va_list VaListAlias;
+    std::va_list va1;
+    VaListAlias va2;
+
+    const int ci = 0;
+    int const ic = 0;
+
+    signed int si1 = 0;
+    int si2 = 0;
+
+    void *x;
+  )";
+
+
+  GetAllTopLevelDecls(code, Decls);
+
+  #include <iostream>
+
+  ASTContext &Ctxt = Interp->getCI()->getASTContext();
+
+  Decls.assign(Decls.end() - 8, Decls.end());
+
+  EXPECT_TRUE(Cpp::IsSameType(Cpp::GetType("bool"), Ctxt.BoolTy.getAsOpaquePtr()));
+  EXPECT_TRUE(Cpp::IsSameType(Cpp::GetType("float"), Ctxt.FloatTy.getAsOpaquePtr()));
+  EXPECT_TRUE(Cpp::IsSameType(Cpp::GetType("long"), Ctxt.LongTy.getAsOpaquePtr()));
+  EXPECT_TRUE(Cpp::IsSameType(Cpp::GetType("long long"), Ctxt.LongLongTy.getAsOpaquePtr()));
+  EXPECT_TRUE(Cpp::IsSameType(Cpp::GetType("short"), Ctxt.ShortTy.getAsOpaquePtr()));
+  EXPECT_TRUE(Cpp::IsSameType(Cpp::GetType("char"), Ctxt.SignedCharTy.getAsOpaquePtr()));
+  EXPECT_TRUE(Cpp::IsSameType(Cpp::GetType("unsigned char"), Ctxt.UnsignedCharTy.getAsOpaquePtr()));
+  EXPECT_TRUE(Cpp::IsSameType(Cpp::GetType("unsigned int"), Ctxt.UnsignedIntTy.getAsOpaquePtr()));
+  EXPECT_TRUE(Cpp::IsSameType(Cpp::GetVariableType(Decls[7]), Ctxt.VoidPtrTy.getAsOpaquePtr()));
+
+  // Expect the typedef to std::va_list to be the same type
+  EXPECT_TRUE(Cpp::IsSameType(Cpp::GetVariableType(Decls[1]), Cpp::GetVariableType(Decls[2])));
+  EXPECT_TRUE(Cpp::IsSameType(Cpp::GetVariableType(Decls[3]), Cpp::GetVariableType(Decls[4])));
+  EXPECT_TRUE(Cpp::IsSameType(Cpp::GetVariableType(Decls[5]), Cpp::GetVariableType(Decls[6])));
+}
+
+TEST(VariableReflectionTest, Is_Get_Reference) {
+  Cpp::CreateInterpreter();
+  std::vector<Decl*> Decls;
+  std::string code = R"(
+  class A {};
+  int a;
+  int &b = a;
+  double c;
+  double &d = c;
+  A e;
+  A &f = e;
+  )";
+
+  GetAllTopLevelDecls(code, Decls);
+
+  EXPECT_FALSE(Cpp::IsReferenceType(Cpp::GetVariableType(Decls[1])));
+  EXPECT_TRUE(Cpp::IsReferenceType(Cpp::GetVariableType(Decls[2])));
+  EXPECT_FALSE(Cpp::IsReferenceType(Cpp::GetVariableType(Decls[3])));
+  EXPECT_TRUE(Cpp::IsReferenceType(Cpp::GetVariableType(Decls[4])));
+  EXPECT_FALSE(Cpp::IsReferenceType(Cpp::GetVariableType(Decls[5])));
+  EXPECT_TRUE(Cpp::IsReferenceType(Cpp::GetVariableType(Decls[6])));
+
+  EXPECT_EQ(Cpp::GetNonReferenceType(Cpp::GetVariableType(Decls[2])),
+            Cpp::GetVariableType(Decls[1]));
+  EXPECT_EQ(Cpp::GetNonReferenceType(Cpp::GetVariableType(Decls[4])),
+            Cpp::GetVariableType(Decls[3]));
+  EXPECT_EQ(Cpp::GetNonReferenceType(Cpp::GetVariableType(Decls[6])),
+            Cpp::GetVariableType(Decls[5]));
+
+  EXPECT_FALSE(Cpp::GetNonReferenceType(Cpp::GetVariableType(Decls[5])));
+}