[libclang] add support for arrays to clang_Cursor_Evaluate

[BartmanAbyss]

Summary

This allows evaluating array initializer such as

int array[4]{1, 2, 3, 4};
const char* str[2]{ "hello", "world" };

Adds CXEval_Array to the CXEvalResultKind enum, clang_EvalResult_getArraySize(), clang_EvalResult_getArrayElt

clang/include/clang-c/Index.h

  * The version constants for the libclang API.
  * CINDEX_VERSION_MINOR should increase when there are API additions.
  * CINDEX_VERSION_MAJOR is intended for "major" source/ABI breaking changes.
  *
  * The policy about the libclang API was always to keep it source and ABI
  * compatible, thus CINDEX_VERSION_MAJOR is expected to remain stable.
  */
 #define CINDEX_VERSION_MAJOR 0
-#define CINDEX_VERSION_MINOR 62
+#define CINDEX_VERSION_MINOR 63
 
 #define CINDEX_VERSION_ENCODE(major, minor) (((major)*10000) + ((minor)*1))
 
 #define CINDEX_VERSION                                                         \
   CINDEX_VERSION_ENCODE(CINDEX_VERSION_MAJOR, CINDEX_VERSION_MINOR)
 
 #define CINDEX_VERSION_STRINGIZE_(major, minor) #major "." #minor
 #define CINDEX_VERSION_STRINGIZE(major, minor)                                 \

 
 typedef enum {
   CXEval_Int = 1,
   CXEval_Float = 2,
   CXEval_ObjCStrLiteral = 3,
   CXEval_StrLiteral = 4,
   CXEval_CFStr = 5,
   CXEval_Other = 6,
+  CXEval_Array = 7,
 
   CXEval_UnExposed = 0
 
 } CXEvalResultKind;
 
 /**
  * Evaluation result of a cursor
  */

 
 /**
  * Returns the evaluation result as double if the
  * kind is double.
  */
 CINDEX_LINKAGE double clang_EvalResult_getAsDouble(CXEvalResult E);
 
 /**
+ * Returns the number of elements if the kind is Array.
+ */
+CINDEX_LINKAGE unsigned clang_EvalResult_getArraySize(CXEvalResult E);
+
+/**
  * Returns the evaluation result as a constant string if the
  * kind is other than Int or float. User must not free this pointer,
  * instead call clang_EvalResult_dispose on the CXEvalResult returned
  * by clang_Cursor_Evaluate.
  */
 CINDEX_LINKAGE const char *clang_EvalResult_getAsStr(CXEvalResult E);
 
 /**
+ * Returns an element for a Array result. User must not call 
+ * clang_EvalResult_dispose on the return value.
+ */
+CINDEX_LINKAGE CXEvalResult clang_EvalResult_getArrayElt(CXEvalResult E, unsigned index);
+
+/**
  * Disposes the created Eval memory.
  */
 CINDEX_LINKAGE void clang_EvalResult_dispose(CXEvalResult E);
 /**
  * @}
  */
 
 /** \defgroup CINDEX_REMAPPING Remapping functions

clang/test/Index/evaluate-cursor.cpp

 const auto the_value = calc_val() + sizeof(char);
 
 void vlaTest() {
   int msize = 4;
   float arr[msize];
   [&arr] {};
 }
 
+class z {
+  int array[4]{1, 2, 3, 4};
+  const char* str[2]{ "hello", "world" };
+};
+
 // RUN: c-index-test -evaluate-cursor-at=%s:4:7 \
 // RUN:    -evaluate-cursor-at=%s:8:7 \
 // RUN:    -evaluate-cursor-at=%s:8:11 -std=c++11 %s | FileCheck %s
 // CHECK: Value: 10
 // CHECK: Value: 11
 // CHECK: Value: 11
 
 // RUN: c-index-test -get-macro-info-cursor-at=%s:11:9 \

 // CHECK-EXPR: unsigned, Value: 4
 // CHECK-EXPR: Value: 3
 // CHECK-EXPR: unsigned, Value: 4
 // CHECK-EXPR: unsigned, Value: 1
 
 // RUN: c-index-test -evaluate-cursor-at=%s:35:5 \
 // RUN:    -std=c++11 %s | FileCheck -check-prefix=VLA %s
 // VLA: Not Evaluatable
+
+// RUN: c-index-test -evaluate-cursor-at=%s:39:9 \
+// RUN:    -std=c++11 %s | FileCheck -check-prefix=CHECK-ARRAY %s
+// CHECK-ARRAY: [0]: { Kind: Int, Value: 1 }
+// CHECK-ARRAY: [1]: { Kind: Int, Value: 2 }
+// CHECK-ARRAY: [2]: { Kind: Int, Value: 3 }
+// CHECK-ARRAY: [3]: { Kind: Int, Value: 4 }
+
+// RUN: c-index-test -evaluate-cursor-at=%s:40:15 \
+// RUN:    -std=c++11 %s | FileCheck -check-prefix=CHECK-ARRAY-STR %s
+// CHECK-ARRAY-STR: [0]: { Kind: CString , Value: hello }
+// CHECK-ARRAY-STR: [1]: { Kind: CString , Value: world }

clang/tools/c-index-test/c-index-test.c

case CXEval_StrLiteral:
       break;
     }
     case CXEval_CFStr:
     {
       const char* str = clang_EvalResult_getAsStr(result);
       printf("Kind: CFString , Value: %s", str);
       break;
     }
+    case CXEval_Array: 
+    {
+      printf("Kind: Array , Value: { ");
+      for (unsigned i = 0; i < clang_EvalResult_getArraySize(result); i++) {
+        if (i > 0) {
+          printf(" , ");
+        }
+        printf("[%d]: { ", i);
+        display_evaluate_results(clang_EvalResult_getArrayElt(result, i));
+        printf(" }");
+      }
+      printf(" }");
+      break;
+    }
     default:
       printf("Unexposed");
       break;
     }
 }
 
 static void inspect_evaluate_cursor(CXCursor Cursor) {
   CXSourceLocation CursorLoc = clang_getCursorLocation(Cursor);

clang/tools/libclang/CIndex.cpp

 
 struct ExprEvalResult {
   CXEvalResultKind EvalType;
   union {
     unsigned long long unsignedVal;
     long long intVal;
     double floatVal;
     char *stringVal;
+    struct {
+      ExprEvalResult *elts;
+      unsigned size;
+    } arrayVal;
   } EvalData;
   bool IsUnsignedInt;
   ~ExprEvalResult() {
-    if (EvalType != CXEval_UnExposed && EvalType != CXEval_Float &&
+    if (EvalType == CXEval_Array) {
+      delete[] EvalData.arrayVal.elts;
+    } else if (EvalType != CXEval_UnExposed && EvalType != CXEval_Float &&
         EvalType != CXEval_Int) {
       delete[] EvalData.stringVal;
     }
   }
 };
 
 void clang_EvalResult_dispose(CXEvalResult E) {
   delete static_cast<ExprEvalResult *>(E);
 }

 
 const char *clang_EvalResult_getAsStr(CXEvalResult E) {
   if (!E) {
     return nullptr;
   }
   return ((ExprEvalResult *)E)->EvalData.stringVal;
 }
 
-static const ExprEvalResult *evaluateExpr(Expr *expr, CXCursor C) {
-  Expr::EvalResult ER;
-  ASTContext &ctx = getCursorContext(C);
-  if (!expr)
-    return nullptr;
+unsigned clang_EvalResult_getArraySize(CXEvalResult E) {
+  if (!E || ((ExprEvalResult *)E)->EvalType != CXEval_Array) {
+    return 0;
+  }
+  return ((ExprEvalResult *)E)->EvalData.arrayVal.size;
+}
 
-  expr = expr->IgnoreParens();
-  if (expr->isValueDependent())
-    return nullptr;
-  if (!expr->EvaluateAsRValue(ER, ctx))
-    return nullptr;
+CXEvalResult clang_EvalResult_getArrayElt(CXEvalResult E, unsigned index) {
+  if (E && ((ExprEvalResult *)E)->EvalType == CXEval_Array &&
+      index < ((ExprEvalResult *)E)->EvalData.arrayVal.size) {
+    return &((ExprEvalResult *)E)->EvalData.arrayVal.elts[index];
+  }
+}
 
-  QualType rettype;
-  CallExpr *callExpr;
-  auto result = std::make_unique<ExprEvalResult>();
-  result->EvalType = CXEval_UnExposed;
-  result->IsUnsignedInt = false;
+static bool evaluateVal(const APValue &val, ExprEvalResult &result) {
+  result.EvalType = CXEval_UnExposed;
+  result.IsUnsignedInt = false;
+
+  if (val.isArray()) {
+    result.EvalType = CXEval_Array;
+    result.EvalData.arrayVal.size = val.getArrayInitializedElts();
+    result.EvalData.arrayVal.elts =
+        new ExprEvalResult[result.EvalData.arrayVal.size];
+    bool ret = true;
+    for (unsigned i = 0; i < result.EvalData.arrayVal.size; i++) {
+      if (!evaluateVal(val.getArrayInitializedElt(i),
+                       result.EvalData.arrayVal.elts[i])) {
+        ret = false;
+      }
+    }
+
+    return ret;
+  }
 
-  if (ER.Val.isInt()) {
-    result->EvalType = CXEval_Int;
+  if (val.isInt()) {
+    result.EvalType = CXEval_Int;
 
-    auto &val = ER.Val.getInt();
-    if (val.isUnsigned()) {
-      result->IsUnsignedInt = true;
-      result->EvalData.unsignedVal = val.getZExtValue();
+    auto &ival = val.getInt();
+    if (ival.isUnsigned()) {
+      result.IsUnsignedInt = true;
+      result.EvalData.unsignedVal = ival.getZExtValue();
     } else {
-      result->EvalData.intVal = val.getExtValue();
+      result.EvalData.intVal = ival.getExtValue();
     }
 
-    return result.release();
+    return true;
   }
 
-  if (ER.Val.isFloat()) {
+  if (val.isFloat()) {
     llvm::SmallVector<char, 100> Buffer;
-    ER.Val.getFloat().toString(Buffer);
+    val.getFloat().toString(Buffer);
     std::string floatStr(Buffer.data(), Buffer.size());
-    result->EvalType = CXEval_Float;
+    result.EvalType = CXEval_Float;
     bool ignored;
-    llvm::APFloat apFloat = ER.Val.getFloat();
+    llvm::APFloat apFloat = val.getFloat();
     apFloat.convert(llvm::APFloat::IEEEdouble(),
                     llvm::APFloat::rmNearestTiesToEven, &ignored);
-    result->EvalData.floatVal = apFloat.convertToDouble();
-    return result.release();
+    result.EvalData.floatVal = apFloat.convertToDouble();
+    return true;
   }
 
+  return false;
+}
+
+static bool evaluateStringExpr(Expr *expr, ASTContext &ctx, ExprEvalResult &result) {
+  QualType rettype;
+  CallExpr *callExpr;
+
   if (expr->getStmtClass() == Stmt::ImplicitCastExprClass) {
     const ImplicitCastExpr *I = dyn_cast<ImplicitCastExpr>(expr);
     auto *subExpr = I->getSubExprAsWritten();
     if (subExpr->getStmtClass() == Stmt::StringLiteralClass ||
         subExpr->getStmtClass() == Stmt::ObjCStringLiteralClass) {
       const StringLiteral *StrE = nullptr;
       const ObjCStringLiteral *ObjCExpr;
       ObjCExpr = dyn_cast<ObjCStringLiteral>(subExpr);
 
       if (ObjCExpr) {
         StrE = ObjCExpr->getString();
-        result->EvalType = CXEval_ObjCStrLiteral;
+        result.EvalType = CXEval_ObjCStrLiteral;
       } else {
         StrE = cast<StringLiteral>(I->getSubExprAsWritten());
-        result->EvalType = CXEval_StrLiteral;
+        result.EvalType = CXEval_StrLiteral;
       }
 
       std::string strRef(StrE->getString().str());
-      result->EvalData.stringVal = new char[strRef.size() + 1];
-      strncpy((char *)result->EvalData.stringVal, strRef.c_str(),
+      result.EvalData.stringVal = new char[strRef.size() + 1];
+      strncpy((char *)result.EvalData.stringVal, strRef.c_str(),
               strRef.size());
-      result->EvalData.stringVal[strRef.size()] = '\0';
-      return result.release();
+      result.EvalData.stringVal[strRef.size()] = '\0';
+      return true;
     }
   } else if (expr->getStmtClass() == Stmt::ObjCStringLiteralClass ||
              expr->getStmtClass() == Stmt::StringLiteralClass) {
     const StringLiteral *StrE = nullptr;
     const ObjCStringLiteral *ObjCExpr;
     ObjCExpr = dyn_cast<ObjCStringLiteral>(expr);
 
     if (ObjCExpr) {
       StrE = ObjCExpr->getString();
-      result->EvalType = CXEval_ObjCStrLiteral;
+      result.EvalType = CXEval_ObjCStrLiteral;
     } else {
       StrE = cast<StringLiteral>(expr);
-      result->EvalType = CXEval_StrLiteral;
+      result.EvalType = CXEval_StrLiteral;
     }
 
     std::string strRef(StrE->getString().str());
-    result->EvalData.stringVal = new char[strRef.size() + 1];
-    strncpy((char *)result->EvalData.stringVal, strRef.c_str(), strRef.size());
-    result->EvalData.stringVal[strRef.size()] = '\0';
-    return result.release();
+    result.EvalData.stringVal = new char[strRef.size() + 1];
+    strncpy((char *)result.EvalData.stringVal, strRef.c_str(), strRef.size());
+    result.EvalData.stringVal[strRef.size()] = '\0';
+    return true;
   }
 
   if (expr->getStmtClass() == Stmt::CStyleCastExprClass) {
     CStyleCastExpr *CC = static_cast<CStyleCastExpr *>(expr);
 
     rettype = CC->getType();
     if (rettype.getAsString() == "CFStringRef" &&
         CC->getSubExpr()->getStmtClass() == Stmt::CallExprClass) {
 
       callExpr = static_cast<CallExpr *>(CC->getSubExpr());
       StringLiteral *S = getCFSTR_value(callExpr);
       if (S) {
         std::string strLiteral(S->getString().str());
-        result->EvalType = CXEval_CFStr;
+        result.EvalType = CXEval_CFStr;
 
-        result->EvalData.stringVal = new char[strLiteral.size() + 1];
-        strncpy((char *)result->EvalData.stringVal, strLiteral.c_str(),
+        result.EvalData.stringVal = new char[strLiteral.size() + 1];
+        strncpy((char *)result.EvalData.stringVal, strLiteral.c_str(),
                 strLiteral.size());
-        result->EvalData.stringVal[strLiteral.size()] = '\0';
-        return result.release();
+        result.EvalData.stringVal[strLiteral.size()] = '\0';
+        return true;
       }
     }
 
   } else if (expr->getStmtClass() == Stmt::CallExprClass) {
     callExpr = static_cast<CallExpr *>(expr);
     rettype = callExpr->getCallReturnType(ctx);
 
     if (rettype->isVectorType() || callExpr->getNumArgs() > 1)
-      return nullptr;
+      return false;
 
     if (rettype->isIntegralType(ctx) || rettype->isRealFloatingType()) {
       if (callExpr->getNumArgs() == 1 &&
           !callExpr->getArg(0)->getType()->isIntegralType(ctx))
-        return nullptr;
+        return false;
     } else if (rettype.getAsString() == "CFStringRef") {
 
       StringLiteral *S = getCFSTR_value(callExpr);
       if (S) {
         std::string strLiteral(S->getString().str());
-        result->EvalType = CXEval_CFStr;
-        result->EvalData.stringVal = new char[strLiteral.size() + 1];
-        strncpy((char *)result->EvalData.stringVal, strLiteral.c_str(),
+        result.EvalType = CXEval_CFStr;
+        result.EvalData.stringVal = new char[strLiteral.size() + 1];
+        strncpy((char *)result.EvalData.stringVal, strLiteral.c_str(),
                 strLiteral.size());
-        result->EvalData.stringVal[strLiteral.size()] = '\0';
-        return result.release();
+        result.EvalData.stringVal[strLiteral.size()] = '\0';
+        return true;
       }
     }
   } else if (expr->getStmtClass() == Stmt::DeclRefExprClass) {
     DeclRefExpr *D = static_cast<DeclRefExpr *>(expr);
     ValueDecl *V = D->getDecl();
     if (V->getKind() == Decl::Function) {
       std::string strName = V->getNameAsString();
-      result->EvalType = CXEval_Other;
-      result->EvalData.stringVal = new char[strName.size() + 1];
-      strncpy(result->EvalData.stringVal, strName.c_str(), strName.size());
-      result->EvalData.stringVal[strName.size()] = '\0';
-      return result.release();
-    }
+      result.EvalType = CXEval_Other;
+      result.EvalData.stringVal = new char[strName.size() + 1];
+      strncpy(result.EvalData.stringVal, strName.c_str(), strName.size());
+      result.EvalData.stringVal[strName.size()] = '\0';
+      return true;
+    }
+  }
+
+  return false;
+}
+
+static const ExprEvalResult *evaluateExpr(Expr *expr, CXCursor C) {
+  Expr::EvalResult ER;
+  ASTContext &ctx = getCursorContext(C);
+  if (!expr)
+    return nullptr;
+
+  expr = expr->IgnoreParens();
+  if (expr->isValueDependent())
+    return nullptr;
+  if (!expr->EvaluateAsRValue(ER, ctx))
+    return nullptr;
+
+  auto result = std::make_unique<ExprEvalResult>();
+  if (evaluateVal(ER.Val, *result)) {
+
+  if (expr->getStmtClass() == Stmt::InitListExprClass) {
+    const InitListExpr *I = dyn_cast<InitListExpr>(expr);
+    // evaluateVal() has already determined that we have CXEval_Array, but some
+    // evaluations failed (because they are not CXEval_Int, CXEval_Float, etc.)
+    // so try evaluating the elements as strings
+    if (result->EvalType == CXEval_Array &&
+        result->EvalData.arrayVal.size >= I->getNumInits()) {
+      for (unsigned i = 0; i < I->getNumInits(); i++) {
+        evaluateStringExpr(const_cast<Expr *>(I->getInit(i)), ctx,
+                           result->EvalData.arrayVal.elts[i]);
+      }
+      return result.release();
+    }
+  }
+
+  if (evaluateStringExpr(expr, ctx, *result)) {
+    return result.release();
   }
 
   return nullptr;
 }
 
 static const Expr *evaluateDeclExpr(const Decl *D) {
   if (!D)
     return nullptr;