Remove OMPLoopCategory enum and Category field

With the rearranged AST hierarchy we don't need it. Storing the original
Stmt should be enough now.

This change also introduces a few helper functions so we can keep the
generation of the analysis and the use of the analysis in sync (this
was previously done through the Category field)

Author: rofirrim

clang/include/clang/Sema/SemaOpenMP.h

@@ -1494,40 +1494,36 @@ class SemaOpenMP : public SemaBase {
       SmallVectorImpl<OMPLoopBasedDirective::HelperExprs> &LoopHelpers,
       Stmt *&Body, SmallVectorImpl<SmallVector<Stmt *>> &OriginalInits);
 
-  /// Categories of loops encountered during semantic OpenMP loop
-  /// analysis.
-  ///
-  /// This enumeration identifies the structural category of a loop or sequence
-  /// of loops analyzed in the context of OpenMP transformations and directives.
-  /// This categorization helps differentiate between original source loops
-  /// and the structures resulting from applying OpenMP loop transformations.
-  enum class OMPLoopCategory {
-    /// @var OMPLoopCategory::RegularLoop
-    /// Represents a standard canonical loop nest found in the
-    /// original source code or an intact loop after transformations
-    /// (i.e Post/Pre loops of a loopranged fusion).
-    RegularLoop,
-
-    /// @var OMPLoopCategory::TransformSingleLoop
-    /// Represents the resulting loop structure when an OpenMP loop
-    /// transformation, generates a single, top-level loop.
-    TransformSingleLoop,
-  };
-
   /// Holds the result of the analysis of a (possibly canonical) loop.
   struct LoopAnalysis {
-    /// Category of the analyzed loop.
-    OMPLoopCategory Category;
+    /// The analyzed loop or loop transformation.
+    Stmt *AStmt;
     /// Loop analyses results.
     OMPLoopBasedDirective::HelperExprs HelperExprs;
-    /// The for-statement of the loop.
+    /// The for-statement of the loop. ForStmt equals AStmt only when the latter
+    /// is a canonical loop (i.e. not a loop transformation).
     Stmt *ForStmt;
     /// Initialization statements before transformations.
     SmallVector<Stmt *> OriginalInits;
     /// Initialization statements required after transformation of this loop.
     SmallVector<Stmt *> TransformsPreInits;
 
-    explicit LoopAnalysis(OMPLoopCategory Category) : Category(Category) {}
+    explicit LoopAnalysis(Stmt *S) : AStmt(S) {}
+
+    bool isRegularLoop() const {
+      return isRegularLoop(AStmt);
+    }
+    bool isLoopTransformation() const {
+      return isLoopTransformation(AStmt);
+    }
+
+    // Convenience functions used when building LoopSequenceAnalysis.
+    static bool isRegularLoop(Stmt *S) {
+      return isa<clang::ForStmt, CXXForRangeStmt>(S);
+    }
+    static bool isLoopTransformation(Stmt *S) {
+      return isa<OMPLoopTransformationDirective>(S);
+    }
   };
 
   /// Holds the result of the analysis of a (possibly canonical) loop sequence.
@@ -1538,6 +1534,12 @@ class SemaOpenMP : public SemaBase {
     SmallVector<LoopAnalysis, 2> Loops;
     /// Additional code required before entering the transformed loop sequence.
     SmallVector<Stmt *> LoopSequencePreInits;
+
+    // Convenience function used when building the LoopSequenceAnalysis.
+    static bool isLoopSequenceDerivation(Stmt *S) {
+      return LoopAnalysis::isRegularLoop(S) ||
+             LoopAnalysis::isLoopTransformation(S);
+    }
   };
 
   /// The main recursive process of `checkTransformableLoopSequence` that

clang/lib/Sema/SemaOpenMP.cpp

@@ -14513,7 +14513,7 @@ bool SemaOpenMP::analyzeLoopSequence(Stmt *LoopSeqStmt,
     // Vast majority: (Tile, Unroll, Stripe, Reverse, Interchange, Fuse all)
     // Process the transformed loop statement
     LoopAnalysis &NewTransformedSingleLoop =
-        SeqAnalysis.Loops.emplace_back(OMPLoopCategory::TransformSingleLoop);
+        SeqAnalysis.Loops.emplace_back(Child);
     unsigned IsCanonical = checkOpenMPLoop(
         Kind, nullptr, nullptr, TransformedStmt, SemaRef, *DSAStack, TmpDSA,
         NewTransformedSingleLoop.HelperExprs);
@@ -14531,7 +14531,7 @@ bool SemaOpenMP::analyzeLoopSequence(Stmt *LoopSeqStmt,
   // Modularized code for handling regular canonical loops.
   auto AnalyzeRegularLoop = [&](Stmt *Child) {
     LoopAnalysis &NewRegularLoop =
-        SeqAnalysis.Loops.emplace_back(OMPLoopCategory::RegularLoop);
+        SeqAnalysis.Loops.emplace_back(Child);
     unsigned IsCanonical =
         checkOpenMPLoop(Kind, nullptr, nullptr, Child, SemaRef, *DSAStack,
                         TmpDSA, NewRegularLoop.HelperExprs);
@@ -14545,21 +14545,12 @@ bool SemaOpenMP::analyzeLoopSequence(Stmt *LoopSeqStmt,
     return true;
   };
 
-  // Helper functions to validate loop sequence grammar derivations.
-  auto IsLoopSequenceDerivation = [](auto *Child) {
-    return isa<ForStmt, CXXForRangeStmt, OMPLoopTransformationDirective>(Child);
-  };
-  // Helper functions to validate loop generating grammar derivations.
-  auto IsLoopGeneratingStmt = [](auto *Child) {
-    return isa<OMPLoopTransformationDirective>(Child);
-  };
-
   // High level grammar validation.
   for (Stmt *Child : LoopSeqStmt->children()) {
     if (!Child)
       continue;
     // Skip over non-loop-sequence statements.
-    if (!IsLoopSequenceDerivation(Child)) {
+    if (!LoopSequenceAnalysis::isLoopSequenceDerivation(Child)) {
       Child = Child->IgnoreContainers();
       // Ignore empty compound statement.
       if (!Child)
@@ -14574,8 +14565,8 @@ bool SemaOpenMP::analyzeLoopSequence(Stmt *LoopSeqStmt,
       }
     }
     // Regular loop sequence handling.
-    if (IsLoopSequenceDerivation(Child)) {
-      if (IsLoopGeneratingStmt(Child)) {
+    if (LoopSequenceAnalysis::isLoopSequenceDerivation(Child)) {
+      if (LoopAnalysis::isLoopTransformation(Child)) {
         if (!AnalyzeLoopGeneration(Child))
           return false;
         // AnalyzeLoopGeneration updates SeqAnalysis.LoopSeqSize accordingly.
@@ -16073,17 +16064,16 @@ StmtResult SemaOpenMP::ActOnOpenMPFuseDirective(ArrayRef<OMPClause *> Clauses,
   // looprange section
   unsigned int TransformIndex = 0;
   for (unsigned I : llvm::seq<unsigned>(FirstVal - 1)) {
-    if (SeqAnalysis.Loops[I].Category == OMPLoopCategory::TransformSingleLoop)
+    if (SeqAnalysis.Loops[I].isLoopTransformation())
       ++TransformIndex;
   }
 
   for (unsigned int I = FirstVal - 1, J = 0; I < LastVal; ++I, ++J) {
-    if (SeqAnalysis.Loops[I].Category == OMPLoopCategory::RegularLoop) {
+    if (SeqAnalysis.Loops[I].isRegularLoop()) {
       addLoopPreInits(Context, SeqAnalysis.Loops[I].HelperExprs,
                       SeqAnalysis.Loops[I].ForStmt,
                       SeqAnalysis.Loops[I].OriginalInits, PreInits);
-    } else if (SeqAnalysis.Loops[I].Category ==
-               OMPLoopCategory::TransformSingleLoop) {
+    } else if (SeqAnalysis.Loops[I].isLoopTransformation()) {
       // For transformed loops, insert both pre-inits and original inits.
       // Order matters: pre-inits may define variables used in the original
       // inits such as upper bounds...
@@ -16352,8 +16342,7 @@ StmtResult SemaOpenMP::ActOnOpenMPFuseDirective(ArrayRef<OMPClause *> Clauses,
       if (I >= FirstVal - 1 && I < FirstVal + CountVal - 1) {
         // Update the Transformation counter to skip already treated
         // loop transformations
-        if (SeqAnalysis.Loops[I].Category !=
-            OMPLoopCategory::TransformSingleLoop)
+        if (!SeqAnalysis.Loops[I].isLoopTransformation())
           ++TransformIndex;
         continue;
       }
@@ -16362,8 +16351,7 @@ StmtResult SemaOpenMP::ActOnOpenMPFuseDirective(ArrayRef<OMPClause *> Clauses,
       // Regular loops: they are kept intact as-is.
       // Loop-sequence-generating transformations: already handled earlier.
       // Only TransformSingleLoop requires inserting pre-inits here
-      if (SeqAnalysis.Loops[I].Category ==
-          OMPLoopCategory::TransformSingleLoop) {
+      if (SeqAnalysis.Loops[I].isRegularLoop()) {
         const auto &TransformPreInit =
             SeqAnalysis.Loops[TransformIndex++].TransformsPreInits;
         if (!TransformPreInit.empty())