[CIndex] #pragma clang transform

[Meinersbur]

Summary

Support for #pragma clang transform in cindex. Like for OpenMP directives, there is no CXCursor for clauses, such that expressions in clauses are visited directly as children of TransformExecutableDirective. CXCursor for clause might be implemented separately.

For a full description, see D69088.

clang/include/clang-c/Index.h

enum CXCursorKind {
   /** OpenMP parallel master taskloop simd directive.
    */
   CXCursor_OMPParallelMasterTaskLoopSimdDirective = 284,
 
   /** OpenMP parallel master directive.
    */
   CXCursor_OMPParallelMasterDirective = 285,
 
-  CXCursor_LastStmt = CXCursor_OMPParallelMasterDirective,
+  /** Transformation directive.
+   */
+  CXCursor_TransformExecutableDirective = 286,
+
+  CXCursor_LastStmt = CXCursor_TransformExecutableDirective,
 
   /**
    * Cursor that represents the translation unit itself.
    *
    * The translation unit cursor exists primarily to act as the root
    * cursor for traversing the contents of a translation unit.
    */
   CXCursor_TranslationUnit = 300,

clang/test/Index/transform.c

+// RUN: c-index-test -test-load-source local -Xclang -fexperimental-transform-pragma %s | FileCheck %s
+
+typedef int int_t;
+struct foo { long x; };
+
+void test() {
+#pragma clang transform unroll partial(2*2)
+  for (int i = 0; i < 8; i += 1)
+    ;
+}
+
+
+// CHECK: transform.c:7:15: TransformExecutableDirective= Extent=[7:15 - 7:44]
+// CHECK: transform.c:7:40: BinaryOperator= Extent=[7:40 - 7:43]
+// CHECK: transform.c:7:40: IntegerLiteral= Extent=[7:40 - 7:41]
+// CHECK: transform.c:7:42: IntegerLiteral= Extent=[7:42 - 7:43]

clang/tools/libclang/CIndex.cpp

public:
   void VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *E);
   void VisitExpressionTraitExpr(const ExpressionTraitExpr *E);
   void VisitUnresolvedMemberExpr(const UnresolvedMemberExpr *U);
   void VisitVAArgExpr(const VAArgExpr *E);
   void VisitSizeOfPackExpr(const SizeOfPackExpr *E);
   void VisitPseudoObjectExpr(const PseudoObjectExpr *E);
   void VisitOpaqueValueExpr(const OpaqueValueExpr *E);
   void VisitLambdaExpr(const LambdaExpr *E);
+  void VisitTransformExecutableDirective(const TransformExecutableDirective *D);
   void VisitOMPExecutableDirective(const OMPExecutableDirective *D);
   void VisitOMPLoopDirective(const OMPLoopDirective *D);
   void VisitOMPParallelDirective(const OMPParallelDirective *D);
   void VisitOMPSimdDirective(const OMPSimdDirective *D);
   void VisitOMPForDirective(const OMPForDirective *D);
   void VisitOMPForSimdDirective(const OMPForSimdDirective *D);
   void VisitOMPSectionsDirective(const OMPSectionsDirective *D);
   void VisitOMPSectionDirective(const OMPSectionDirective *D);
void EnqueueVisitor::VisitLambdaExpr(const LambdaExpr *E) {
   AddStmt(E->getBody());
   WL.push_back(LambdaExprParts(E, Parent));
 }
 void EnqueueVisitor::VisitPseudoObjectExpr(const PseudoObjectExpr *E) {
   // Treat the expression like its syntactic form.
   Visit(E->getSyntacticForm());
 }
 
+void EnqueueVisitor::VisitTransformExecutableDirective(
+    const TransformExecutableDirective *D) {
+  VisitStmt(D);
+
+  // Visit expressions used in clauses before the loop.
+  // TODO: Currently, the clauses have no CXCursor representation, such that
+  // they cannot be visited themselves. Therefore these expressions appear to be
+  // children of the TransformExecutableDirective.
+  for (const TransformClause *C : D->clauses())
+    for (const Stmt *S : C->children())
+      AddStmt(S);
+}
+
 void EnqueueVisitor::VisitOMPExecutableDirective(
   const OMPExecutableDirective *D) {
   EnqueueChildren(D);
   for (ArrayRef<OMPClause *>::iterator I = D->clauses().begin(),
                                        E = D->clauses().end();
        I != E; ++I)
     EnqueueChildren(*I);
 }
CXString clang_getCursorKindSpelling(enum CXCursorKind Kind) {
   case CXCursor_ConvergentAttr:
       return cxstring::createRef("attribute(convergent)");
   case CXCursor_WarnUnusedAttr:
       return cxstring::createRef("attribute(warn_unused)");
   case CXCursor_WarnUnusedResultAttr:
       return cxstring::createRef("attribute(warn_unused_result)");
   case CXCursor_AlignedAttr:
       return cxstring::createRef("attribute(aligned)");
+  case CXCursor_TransformExecutableDirective:
+    return cxstring::createRef("TransformExecutableDirective");
   }
 
   llvm_unreachable("Unhandled CXCursorKind");
 }
 
 struct GetCursorData {
   SourceLocation TokenBeginLoc;
   bool PointsAtMacroArgExpansion;

clang/tools/libclang/CXCursor.cpp

case Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass:
     break;
   case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass:
     K = CXCursor_OMPTargetTeamsDistributeSimdDirective;
     break;
   case Stmt::BuiltinBitCastExprClass:
     K = CXCursor_BuiltinBitCastExpr;
     break;
   case Stmt::TransformExecutableDirectiveClass:
-    llvm_unreachable("not implemented");
+    K = CXCursor_TransformExecutableDirective;
+    break;
   }
 
   CXCursor C = { K, 0, { Parent, S, TU } };
   return C;
 }
 
 CXCursor cxcursor::MakeCursorObjCSuperClassRef(ObjCInterfaceDecl *Super,
                                                SourceLocation Loc,

clang/tools/libclang/CursorVisitor.h

enum Kind {
     DeclRefExprPartsKind,
     LabelRefVisitKind,
     ExplicitTemplateArgsVisitKind,
     NestedNameSpecifierLocVisitKind,
     DeclarationNameInfoVisitKind,
     MemberRefVisitKind,
     SizeOfPackExprPartsKind,
     LambdaExprPartsKind,
-    PostChildrenVisitKind
+    PostChildrenVisitKind,
+    TransformClauseVisitKind
   };
 
 protected:
   const void *data[3];
   CXCursor parent;
   Kind K;
   VisitorJob(CXCursor C, Kind k, const void *d1, const void *d2 = nullptr,
              const void *d3 = nullptr)