misc. updates

Author: Gnimuc

include/clang-c/CXCppInterOp.h

@@ -358,21 +358,19 @@ bool clang_qualtype_isTypeDerivedFrom(CXQualType derived, CXQualType base);
  * Describes the kind of entity that a scope refers to.
  */
 enum CXScopeKind {
-  CXScope_Unexposed = 0,
-  CXScope_Invalid = 1,
-  /** The global scope. */
-  CXScope_Global = 2,
-  /** Namespaces. */
-  CXScope_Namespace = 3,
-  /** Function, methods, constructor etc. */
-  CXScope_Function = 4,
-  /** Variables. */
-  CXScope_Variable = 5,
-  /** Enum Constants. */
-  CXScope_EnumConstant = 6,
-  /** Fields. */
-  CXScope_Field = 7,
-  // reserved for future use
+  CXScope_Unexposed = 1, // FIXME: merge with CXCursorKind?
+  CXScope_Typedef = 20,
+  CXScope_Namespace = 22,
+  CXScope_ClassTemplate = 31,
+  CXScope_TypeAlias = 36,
+  CXScope_Invalid = 70,
+  CXScope_TranslationUnit = 350,
+
+  CXScope_Record,
+  CXScope_Function,
+  CXScope_Variable,
+  CXScope_EnumConstant,
+  CXScope_Field,
 };
 
 /**
@@ -835,8 +833,6 @@ CXObject clang_construct(CXScope scope, void* arena);
  * Calls the destructor of object of type \c type. When withFree is true it
  * calls operator delete/free.
  *
- * \param I The interpreter.
- *
  * \param This The object to destruct.
  *
  * \param type The type of the object.

lib/Interpreter/CXCppInterOp.cpp

@@ -71,7 +71,11 @@ TInterp_t clang_interpreter_takeInterpreterAsPtr(CXInterpreter I) {
 }
 
 enum CXErrorCode clang_interpreter_Undo(CXInterpreter I, unsigned int N) {
+#ifdef USE_CLING
+  return CXError_Failure;
+#else
   return getInterpreter(I)->Undo(N) ? CXError_Failure : CXError_Success;
+#endif // USE_CLING
 }
 
 void clang_interpreter_dispose(CXInterpreter I) {
@@ -286,19 +290,6 @@ CXQualType clang_qualtype_getCanonicalType(CXQualType type) {
   return makeCXQualType(getMeta(type), QT.getCanonicalType());
 }
 
-namespace Cpp {
-clang::QualType GetType(const std::string& name, clang::Sema& sema);
-} // namespace Cpp
-
-CXQualType clang_qualtype_getType(CXInterpreter I, const char* name) {
-  auto& S = getInterpreter(I)->getSema();
-  const clang::QualType QT = Cpp::GetType(std::string(name), S);
-  if (QT.isNull())
-    return makeCXQualType(I, QT, CXType_Invalid);
-
-  return makeCXQualType(I, QT);
-}
-
 CXQualType clang_qualtype_getComplexType(CXQualType eltype) {
   const auto& C = getInterpreter(eltype)->getSema().getASTContext();
   return makeCXQualType(getMeta(eltype), C.getComplexType(getType(eltype)));
@@ -353,6 +344,28 @@ static inline compat::Interpreter* getInterpreter(const CXScope& S) {
 
 void clang_scope_dump(CXScope S) { getDecl(S)->dump(); }
 
+namespace Cpp {
+clang::QualType GetBuiltinType(const std::string& name, clang::Sema& sema);
+} // namespace Cpp
+
+CXQualType clang_qualtype_getType(CXInterpreter I, const char* name) {
+  auto& S = getInterpreter(I)->getSema();
+  const clang::QualType builtin = Cpp::GetBuiltinType(std::string(name), S);
+  if (!builtin.isNull())
+    return makeCXQualType(I, builtin);
+
+  auto scope = clang_scope_getNamed(name, clang_scope_getGlobalScope(I));
+  if (isNull(scope))
+    return makeCXQualType(I, clang::QualType(), CXType_Invalid);
+
+  if (auto* TD = llvm::dyn_cast_or_null<clang::TypeDecl>(getDecl(scope))) {
+    auto QT = clang::QualType(TD->getTypeForDecl(), 0);
+    return makeCXQualType(I, QT);
+  }
+
+  return makeCXQualType(I, clang::QualType(), CXType_Invalid);
+}
+
 CXQualType clang_scope_getTypeFromScope(CXScope S) {
   if (isNull(S))
     return makeCXQualType(getMeta(S), clang::QualType(), CXType_Invalid);
@@ -605,7 +618,7 @@ CXScopeSet* clang_scope_getUsingNamespaces(CXScope S) {
 CXScope clang_scope_getGlobalScope(CXInterpreter I) {
   const auto& C = getInterpreter(I)->getSema().getASTContext();
   auto* DC = C.getTranslationUnitDecl();
-  return makeCXScope(I, DC, CXScope_Global);
+  return makeCXScope(I, DC, CXScope_TranslationUnit);
 }
 
 CXScope clang_scope_getUnderlyingScope(CXScope S) {
@@ -627,11 +640,21 @@ CXScope clang_scope_getScope(const char* name, CXScope parent) {
     return S;
 
   auto* ND = llvm::dyn_cast<clang::NamedDecl>(getDecl(S));
-  if (llvm::isa<clang::NamespaceDecl>(ND) || llvm::isa<clang::RecordDecl>(ND) ||
-      llvm::isa<clang::ClassTemplateDecl>(ND) ||
-      llvm::isa<clang::TypedefNameDecl>(ND)) {
-    return makeCXScope(getMeta(S), ND->getCanonicalDecl());
-  }
+  if (llvm::isa<clang::NamespaceDecl>(ND))
+    return makeCXScope(getMeta(S), ND->getCanonicalDecl(), CXScope_Namespace);
+
+  if (llvm::isa<clang::TypedefDecl>(ND))
+    return makeCXScope(getMeta(S), ND->getCanonicalDecl(), CXScope_Typedef);
+
+  if (llvm::isa<clang::TypeAliasDecl>(ND))
+    return makeCXScope(getMeta(S), ND->getCanonicalDecl(), CXScope_TypeAlias);
+
+  if (llvm::isa<clang::RecordDecl>(ND))
+    return makeCXScope(getMeta(S), ND->getCanonicalDecl(), CXScope_Record);
+
+  if (llvm::isa<clang::ClassTemplateDecl>(ND))
+    return makeCXScope(getMeta(S), ND->getCanonicalDecl(),
+                       CXScope_ClassTemplate);
 
   return S;
 }

lib/Interpreter/CppInterOp.cpp

@@ -571,27 +571,21 @@ namespace Cpp {
     return GetScope(name.substr(start, end), curr_scope);
   }
 
-  Decl* GetNamedImpl(Sema* sema, const std::string& name,
-                     Decl* parent /*= nullptr*/) {
+  TCppScope_t GetNamed(const std::string& name,
+                       TCppScope_t parent /*= nullptr*/) {
     clang::DeclContext *Within = 0;
     if (parent) {
-      Decl* D = GetUnderlyingScope(parent);
+      auto* D = (clang::Decl*)parent;
+      D = GetUnderlyingScope(D);
       Within = llvm::dyn_cast<clang::DeclContext>(D);
     }
 
-    auto* ND = Cpp_utils::Lookup::Named(sema, name, Within);
+    auto* ND = Cpp_utils::Lookup::Named(&getSema(), name, Within);
     if (ND && ND != (clang::NamedDecl*) -1) {
-      return ND->getCanonicalDecl();
+      return (TCppScope_t)(ND->getCanonicalDecl());
     }
 
-    return nullptr;
-  }
-
-  TCppScope_t GetNamed(const std::string& name,
-                       TCppScope_t parent /*= nullptr*/) {
-    auto& sema = getSema();
-    auto* D = static_cast<Decl*>(parent);
-    return GetNamedImpl(&sema, name, D);
+    return 0;
   }
 
   TCppScope_t GetParentScope(TCppScope_t scope)
@@ -1457,17 +1451,8 @@ namespace Cpp {
     }
   }
 
-  QualType GetType(const std::string& name, Sema& sema) {
-    QualType builtin = findBuiltinType(name, sema.getASTContext());
-    if (!builtin.isNull())
-      return builtin;
-
-    auto* D = (Decl*)GetNamedImpl(&sema, name, /* Within= */ 0);
-    if (auto* TD = llvm::dyn_cast_or_null<TypeDecl>(D)) {
-      return QualType(TD->getTypeForDecl(), 0);
-    }
-
-    return QualType();
+  QualType GetBuiltinType(const std::string& name, Sema& sema) {
+    return findBuiltinType(name, sema.getASTContext());
   }
 
   TCppType_t GetType(const std::string &name) {

unittests/CppInterOp/ScopeReflectionTest.cpp

@@ -783,7 +783,7 @@ TEST(ScopeReflectionTest, GetNamed) {
   auto NS_N1 = clang_scope_getNamed("N1", GS);
   auto NS_N2 = clang_scope_getNamed("N2", NS_N1);
   auto CL_C = clang_scope_getNamed("C", NS_N2);
-  auto EN_E = clang_scope_getScope("E", CL_C);
+  auto EN_E = clang_scope_getNamed("E", CL_C);
 
   EXPECT_EQ(C_API_SHIM(NS_N1), "N1");
   EXPECT_EQ(C_API_SHIM(NS_N2), "N1::N2");