Implement GetUnderlyingScope

Author: sudo-panda

include/clang/Interpreter/CppInterOp.h

@@ -220,6 +220,10 @@ namespace Cpp {
   /// Gets the global scope of the whole C++  instance.
   TCppScope_t GetGlobalScope();
 
+  /// Strips the typedef and returns the underlying class, and if the
+  /// underlying decl is not a class it returns the input unchanged.
+  TCppScope_t GetUnderlyingScope(TCppScope_t scope);
+
   /// Gets the namespace or class for the name passed as a parameter,
   /// and if the parent is not passed, then global scope will be assumed.
   TCppScope_t GetScope(const std::string &name, TCppScope_t parent = 0);

lib/Interpreter/CppInterOp.cpp

@@ -462,6 +462,39 @@ namespace Cpp {
     return getSema().getASTContext().getTranslationUnitDecl();
   }
 
+  static Decl *GetScopeFromType(QualType QT) {
+    if (auto *Type = QT.getTypePtrOrNull()) {
+      Type = Type->getPointeeOrArrayElementType();
+      Type = Type->getUnqualifiedDesugaredType();
+      if (auto *ET = llvm::dyn_cast<EnumType>(Type))
+        return ET->getDecl();
+      return Type->getAsCXXRecordDecl();
+    }
+    return 0;
+  }
+
+  TCppScope_t GetScopeFromType(TCppType_t type)
+  {
+    QualType QT = QualType::getFromOpaquePtr(type);
+    return (TCppScope_t) GetScopeFromType(QT);
+  }
+
+  static clang::Decl* GetUnderlyingScope(clang::Decl * D) {
+    if (auto *TND = dyn_cast_or_null<TypedefNameDecl>(D)) {
+      auto Scope = GetScopeFromType(TND->getUnderlyingType());
+      if (Scope)
+        D = Scope;
+    }
+
+    return D;
+  }
+
+  TCppScope_t GetUnderlyingScope(TCppScope_t scope) {
+    if (!scope)
+      return 0;
+    return GetUnderlyingScope((clang::Decl *) scope);
+  }
+
   TCppScope_t GetScope(const std::string &name, TCppScope_t parent)
   {
     if (name == "")
@@ -494,28 +527,13 @@ namespace Cpp {
     return GetScope(name.substr(start, end), curr_scope);
   }
 
-  static CXXRecordDecl *GetScopeFromType(QualType QT) {
-    if (auto *Type = QT.getTypePtrOrNull()) {
-      Type = Type->getPointeeOrArrayElementType();
-      Type = Type->getUnqualifiedDesugaredType();
-      return Type->getAsCXXRecordDecl();
-    }
-    return 0;
-  }
-
-  TCppScope_t GetScopeFromType(TCppType_t type) {
-    QualType QT = QualType::getFromOpaquePtr(type);
-    return (TCppScope_t)GetScopeFromType(QT);
-  }
-
   TCppScope_t GetNamed(const std::string &name,
                        TCppScope_t parent /*= nullptr*/)
   {
     clang::DeclContext *Within = 0;
     if (parent) {
       auto *D = (clang::Decl *)parent;
-      if (auto *TD = dyn_cast<TypedefNameDecl>(D))
-        D = GetScopeFromType(TD->getUnderlyingType());
+      D = GetUnderlyingScope(D);
       Within = llvm::dyn_cast<clang::DeclContext>(D);
     }
 
@@ -734,8 +752,7 @@ namespace Cpp {
     if (!scope || name.empty())
       return {};
 
-    if (auto *TD = llvm::dyn_cast<TypedefNameDecl>(D))
-      D = GetScopeFromType(TD->getUnderlyingType());
+    D = GetUnderlyingScope(D);
 
     std::vector<TCppFunction_t> funcs;
     llvm::StringRef Name(name);

unittests/CppInterOp/ScopeReflectionTest.cpp

@@ -330,6 +330,24 @@ TEST(ScopeReflectionTest, GetGlobalScope) {
   EXPECT_EQ(Cpp::GetName(Cpp::GetGlobalScope()), "");
 }
 
+TEST(ScopeReflectionTest, GetUnderlyingScope) {
+  std::vector<Decl *> Decls;
+  std::string code = R"(
+    namespace N {
+      class C {};
+    }
+
+    typedef N::C NC;
+    typedef int INT;
+  )";
+
+  GetAllTopLevelDecls(code, Decls);
+
+  EXPECT_EQ(Cpp::GetQualifiedName(Cpp::GetUnderlyingScope(Decls[0])), "N");
+  EXPECT_EQ(Cpp::GetQualifiedName(Cpp::GetUnderlyingScope(Decls[1])), "N::C");
+  EXPECT_EQ(Cpp::GetQualifiedName(Cpp::GetUnderlyingScope(Decls[2])), "INT");
+}
+
 TEST(ScopeReflectionTest, GetScope) {
   std::string code = R"(namespace N {
                         class C {