Merge branch 'main' into Update-to-llvm-20

Author: mcbarton

.github/workflows/MacOS.yml

@@ -133,7 +133,6 @@ jobs:
       if: ${{ steps.cache.outputs.cache-hit != 'true' }}
       run: |
         brew update
-        brew remove [email protected]
         # workaround for https://github.com/actions/setup-python/issues/577
         for pkg in $(brew list | grep '^python@'); do
           brew unlink "$pkg"
@@ -335,7 +334,6 @@ jobs:
     - name: Install deps
       run: |
         brew update --force 
-        brew remove [email protected]
         brew remove swiftlint
         # workaround for https://github.com/actions/setup-python/issues/577
         for pkg in $(brew list | grep '^python@'); do

.github/workflows/emscripten.yml

@@ -241,8 +241,6 @@ jobs:
         export ARCHITECHURE=$(uname -m)
         if [[ "$ARCHITECHURE" != "x86_64" ]]; then
           brew remove unxip
-        else
-          brew remove [email protected]
         fi
         # workaround for https://github.com/actions/setup-python/issues/577
         for pkg in $(brew list | grep '^python@'); do

CMakeLists.txt

@@ -59,6 +59,7 @@ set(CMAKE_CXX_EXTENSIONS NO)
 include(GNUInstallDirs)
   option(CPPINTEROP_USE_CLING "Use Cling as backend" OFF)
   option(CPPINTEROP_USE_REPL "Use clang-repl as backend" ON)
+  option(CPPINTEROP_ENABLE_TESTING "Enable the CppInterOp testing infrastructure." ON)
 
   if (CPPINTEROP_USE_CLING AND CPPINTEROP_USE_REPL)
     message(FATAL_ERROR "We can only use Cling (CPPINTEROP_USE_CLING=On) or Repl (CPPINTEROP_USE_REPL=On), but not both of them.")
@@ -453,10 +454,7 @@ option(CPPINTEROP_ENABLE_SPHINX "Use sphinx to generage CppInterOp user document
 
 if(EMSCRIPTEN)
     message("Build with emscripten")
-    option(CPPINTEROP_ENABLE_TESTING "Enables the testing infrastructure." OFF)
-else()
-    message("Build with cmake")
-    option(CPPINTEROP_ENABLE_TESTING "Enables the testing infrastructure." ON)
+    set(CPPINTEROP_ENABLE_TESTING OFF)
 endif()
 
 if(MSVC)

VERSION

@@ -1 +1 @@
-1.6.0;dev
+1.7.0;dev

docs/ReleaseNotes.md

@@ -1,7 +1,7 @@
 # Introduction
 
 This document contains the release notes for the language interoperability
-library CppInterOp, release 1.6.0. CppInterOp is built on top of
+library CppInterOp, release 1.7.0. CppInterOp is built on top of
 [Clang](http://clang.llvm.org) and [LLVM](http://llvm.org%3E) compiler
 infrastructure. Here we describe the status of CppInterOp in some detail,
 including major improvements from the previous release and new feature work.
@@ -16,7 +16,7 @@ interoperability on the fly. In such scenarios CppInterOp can be used to provide
 the necessary introspection information to the other side helping the language
 cross talk.
 
-## What's New in CppInterOp 1.6.0?
+## What's New in CppInterOp 1.7.0?
 
 Some of the major new features and improvements to CppInterOp are listed here.
 Generic improvements to CppInterOp as a whole or to its underlying
@@ -48,7 +48,7 @@ infrastructure are described first.
 [XXX](https://github.com/compiler-research/CppInterOp/issues/XXX)
 
 <!---Get release bugs
- git log v1.5.0..main | grep 'Fixes|Closes'
+ git log v1.6.0..main | grep 'Fixes|Closes'
  --->
 
 ## Special Kudos
@@ -61,6 +61,6 @@ FirstName LastName (#commits)
 A B (N)
 
 <!---Find contributor list for this release
- git log --pretty=format:"%an"  v1.5.0...main | sort | uniq -c | sort -rn |\
+ git log --pretty=format:"%an"  v1.6.0...main | sort | uniq -c | sort -rn |\
    sed -E 's,^ *([0-9]+) (.*)$,\2 \(\1\),'
 --->

include/clang/Interpreter/CppInterOp.h

@@ -504,6 +504,18 @@ namespace Cpp {
   /// Checks if the provided parameter is a Plain Old Data Type (POD).
   CPPINTEROP_API bool IsPODType(TCppType_t type);
 
+  /// Checks if type is a pointer
+  CPPINTEROP_API bool IsPointerType(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 that the reference refers to
+  CPPINTEROP_API TCppType_t GetNonReferenceType(TCppType_t type);
+
   /// Gets the pure, Underlying Type (as opposed to the Using Type).
   CPPINTEROP_API TCppType_t GetUnderlyingType(TCppType_t type);
 

lib/Interpreter/CppInterOp.cpp

@@ -1493,6 +1493,30 @@ namespace Cpp {
     return QT.isPODType(getASTContext());
   }
 
+  bool IsPointerType(TCppType_t type) {
+    QualType QT = QualType::getFromOpaquePtr(type);
+    return QT->isPointerType();
+  }
+
+  TCppType_t GetPointeeType(TCppType_t type) {
+    if (!IsPointerType(type))
+      return nullptr;
+    QualType QT = QualType::getFromOpaquePtr(type);
+    return QT->getPointeeType().getAsOpaquePtr();
+  }
+
+  bool IsReferenceType(TCppType_t type) {
+    QualType QT = QualType::getFromOpaquePtr(type);
+    return QT->isReferenceType();
+  }
+
+  TCppType_t GetNonReferenceType(TCppType_t type) {
+    if (!IsReferenceType(type))
+      return nullptr;
+    QualType QT = QualType::getFromOpaquePtr(type);
+    return QT.getNonReferenceType().getAsOpaquePtr();
+  }
+
   TCppType_t GetUnderlyingType(TCppType_t type)
   {
     QualType QT = QualType::getFromOpaquePtr(type);
@@ -1862,10 +1886,22 @@ namespace Cpp {
       {
         std::string name;
         {
-          llvm::raw_string_ostream stream(name);
+          std::string complete_name;
+          llvm::raw_string_ostream stream(complete_name);
           FD->getNameForDiagnostic(stream,
                                    FD->getASTContext().getPrintingPolicy(),
                                    /*Qualified=*/false);
+
+          // insert space between template argument list and the function name
+          // this is require if the function is `operator<`
+          // `operator<<type1, type2, ...>` is invalid syntax
+          // whereas `operator< <type1, type2, ...>` is valid
+          std::string simple_name = FD->getNameAsString();
+          size_t idx = complete_name.find(simple_name, 0) + simple_name.size();
+          std::string name_without_template_args = complete_name.substr(0, idx);
+          std::string template_args = complete_name.substr(idx);
+          name = name_without_template_args +
+                 (template_args.empty() ? "" : " " + template_args);
         }
         callbuf << name;
       }

unittests/CppInterOp/FunctionReflectionTest.cpp

@@ -1043,6 +1043,34 @@ TEST(FunctionReflectionTest, GetFunctionCallWrapper) {
   FCI_f.Invoke(&res, {nullptr, 0});
   EXPECT_TRUE(res);
 #endif
+
+  // templated operators
+  Interp->process(R"(
+    class TOperator{
+    public:
+      template<typename T>
+      bool operator<(T t) { return true; }
+    };
+  )");
+  Cpp::TCppScope_t TOperator = Cpp::GetNamed("TOperator");
+
+  auto* TOperatorCtor = Cpp::GetDefaultConstructor(TOperator);
+  auto FCI_TOperatorCtor = Cpp::MakeFunctionCallable(TOperatorCtor);
+  void* toperator = nullptr;
+  FCI_TOperatorCtor.Invoke((void*)&toperator);
+
+  EXPECT_TRUE(toperator);
+  std::vector<Cpp::TCppScope_t> operators;
+  Cpp::GetOperator(TOperator, Cpp::OP_Less, operators);
+  EXPECT_EQ(operators.size(), 1);
+
+  Cpp::TCppScope_t op_templated = operators[0];
+  auto TAI = Cpp::TemplateArgInfo(Cpp::GetType("int"));
+  Cpp::TCppScope_t op = Cpp::InstantiateTemplate(op_templated, &TAI, 1);
+  auto FCI_op = Cpp::MakeFunctionCallable(op);
+  bool boolean = false;
+  FCI_op.Invoke((void*)&boolean, {args, /*args_size=*/1}, object);
+  EXPECT_TRUE(boolean);
 }
 
 TEST(FunctionReflectionTest, IsConstMethod) {

unittests/CppInterOp/VariableReflectionTest.cpp

@@ -600,3 +600,67 @@ TEST(VariableReflectionTest, GetEnumConstantDatamembers) {
   Cpp::GetEnumConstantDatamembers(MyEnumClass, datamembers2, false);
   EXPECT_EQ(datamembers2.size(), 6);
 }
+
+TEST(VariableReflectionTest, Is_Get_Pointer) {
+  Cpp::CreateInterpreter();
+  std::vector<Decl*> Decls;
+  std::string code = R"(
+  class A {};
+  int a;
+  int *b;
+  double c;
+  double *d;
+  A e;
+  A *f;
+  )";
+
+  GetAllTopLevelDecls(code, Decls);
+
+  EXPECT_FALSE(Cpp::IsPointerType(Cpp::GetVariableType(Decls[1])));
+  EXPECT_TRUE(Cpp::IsPointerType(Cpp::GetVariableType(Decls[2])));
+  EXPECT_FALSE(Cpp::IsPointerType(Cpp::GetVariableType(Decls[3])));
+  EXPECT_TRUE(Cpp::IsPointerType(Cpp::GetVariableType(Decls[4])));
+  EXPECT_FALSE(Cpp::IsPointerType(Cpp::GetVariableType(Decls[5])));
+  EXPECT_TRUE(Cpp::IsPointerType(Cpp::GetVariableType(Decls[6])));
+
+  EXPECT_EQ(Cpp::GetPointeeType(Cpp::GetVariableType(Decls[2])),
+            Cpp::GetVariableType(Decls[1]));
+  EXPECT_EQ(Cpp::GetPointeeType(Cpp::GetVariableType(Decls[4])),
+            Cpp::GetVariableType(Decls[3]));
+  EXPECT_EQ(Cpp::GetPointeeType(Cpp::GetVariableType(Decls[6])),
+            Cpp::GetVariableType(Decls[5]));
+
+  EXPECT_FALSE(Cpp::GetPointeeType(Cpp::GetVariableType(Decls[5])));
+}
+
+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])));
+}