[libclang] check that the cursor is declaration before trying to evaluate the cursor like a declaration

[arphaman]

Summary

There's a bug in libclang in which it tries to evaluate a statement cursor as a declaration cursor, because that statement still has a pointer to the declaration parent. This patch fixes it.

rdar://38888477

[dexonsmith]

LGTM.

tools/libclang/CIndex.cpp

3892–3922 ↗

(On Diff #154479)

There's unfortunate nesting here. It would be nice if, either pre-commit or post-commit, you could refactor this to be more straightline using early returns. E.g.:

static CXEvalResult evaluateDeclExpr(const Decl *D) {
  if (!D)
    return nullptr;
  // ...
}
static CXEvalResult evaluateCompoundStmtExpr(const CompoundStmt *CS) {
  if (!CS)
    return nullptr;
  // ...
}
CXEvalResult clang_Cursor_Evaluate(CXCursor C) {
  if (clang_isDeclaration(C.kind)) {
    return evaluateDeclExpr(getCursorDecl(C));
  return evaluateCompoundStmtExpr(
      dyn_cast_or_null<CompoundStmt>(getCursorStmt(C)));
}

[arphaman]

tools/libclang/CIndex.cpp

3892–3922 ↗

(On Diff #154479)

Thanks, will do post commit.

cfe/trunk/tools/libclang/CIndex.cpp

if (V->getKind() == Decl::Function) {
       return result.release();
     }
   }
 
   return nullptr;
 }
 
 CXEvalResult clang_Cursor_Evaluate(CXCursor C) {
+  if (clang_getCursorKind(C) == CXCursor_CompoundStmt) {
+    const CompoundStmt *compoundStmt = cast<CompoundStmt>(getCursorStmt(C));
+    Expr *expr = nullptr;
+    for (auto *bodyIterator : compoundStmt->body()) {
+      if ((expr = dyn_cast<Expr>(bodyIterator))) {
+        break;
+      }
+    }
+    if (expr)
+      return const_cast<CXEvalResult>(
+          reinterpret_cast<const void *>(evaluateExpr(expr, C)));
+  }
+
   const Decl *D = getCursorDecl(C);
   if (D) {
     const Expr *expr = nullptr;
     if (auto *Var = dyn_cast<VarDecl>(D)) {
       expr = Var->getInit();
     } else if (auto *Field = dyn_cast<FieldDecl>(D)) {
       expr = Field->getInClassInitializer();
     }
     if (expr)
       return const_cast<CXEvalResult>(reinterpret_cast<const void *>(
           evaluateExpr(const_cast<Expr *>(expr), C)));
     return nullptr;
   }
-
-  const CompoundStmt *compoundStmt = dyn_cast_or_null<CompoundStmt>(getCursorStmt(C));
-  if (compoundStmt) {
-    Expr *expr = nullptr;
-    for (auto *bodyIterator : compoundStmt->body()) {
-      if ((expr = dyn_cast<Expr>(bodyIterator))) {
-        break;
-      }
-    }
-    if (expr)
-      return const_cast<CXEvalResult>(
-          reinterpret_cast<const void *>(evaluateExpr(expr, C)));
-  }
   return nullptr;
 }
 
 unsigned clang_Cursor_hasAttrs(CXCursor C) {
   const Decl *D = getCursorDecl(C);
   if (!D) {
     return 0;
   }

cfe/trunk/unittests/libclang/LibclangTest.cpp

TEST_F(LibclangParseTest, AllSkippedRanges) {
   EXPECT_EQ(2U, line);
   cxl = clang_getRangeEnd(Ranges->ranges[1]);
   clang_getSpellingLocation(cxl, nullptr, &line, nullptr, nullptr);
   EXPECT_EQ(4U, line);
 
   clang_disposeSourceRangeList(Ranges);
 }
 
+TEST_F(LibclangParseTest, EvaluateChildExpression) {
+  std::string Main = "main.m";
+  WriteFile(Main, "#define kFOO @\"foo\"\n"
+                  "void foobar(void) {\n"
+                  " {kFOO;}\n"
+                  "}\n");
+  ClangTU = clang_parseTranslationUnit(Index, Main.c_str(), nullptr, 0, nullptr,
+                                       0, TUFlags);
+
+  CXCursor C = clang_getTranslationUnitCursor(ClangTU);
+  clang_visitChildren(
+      C,
+      [](CXCursor cursor, CXCursor parent,
+         CXClientData client_data) -> CXChildVisitResult {
+        if (clang_getCursorKind(cursor) == CXCursor_FunctionDecl) {
+          int numberedStmt = 0;
+          clang_visitChildren(
+              cursor,
+              [](CXCursor cursor, CXCursor parent,
+                 CXClientData client_data) -> CXChildVisitResult {
+                int &numberedStmt = *((int *)client_data);
+                if (clang_getCursorKind(cursor) == CXCursor_CompoundStmt) {
+                  if (numberedStmt) {
+                    CXEvalResult RE = clang_Cursor_Evaluate(cursor);
+                    EXPECT_NE(RE, nullptr);
+                    EXPECT_EQ(clang_EvalResult_getKind(RE),
+                              CXEval_ObjCStrLiteral);
+                    return CXChildVisit_Break;
+                  }
+                  numberedStmt++;
+                }
+                return CXChildVisit_Recurse;
+              },
+              &numberedStmt);
+          EXPECT_EQ(numberedStmt, 1);
+        }
+        return CXChildVisit_Continue;
+      },
+      nullptr);
+}
+
 class LibclangReparseTest : public LibclangParseTest {
 public:
   void DisplayDiagnostics() {
     unsigned NumDiagnostics = clang_getNumDiagnostics(ClangTU);
     for (unsigned i = 0; i < NumDiagnostics; ++i) {
       auto Diag = clang_getDiagnostic(ClangTU, i);
       LLVM_DEBUG(llvm::dbgs()
                  << clang_getCString(clang_formatDiagnostic(