[clang][OpenMP] Revert "OMPFlushClause is synthetic, no such clause exists"

[lebedev.ri]

Summary

This reverts rL352390 / D57280.

As discussed in https://reviews.llvm.org/D57112#inline-506781,
'flush' clause does not exist in the OpenMP spec, it can not be
specified, and OMPFlushClause class is just a helper class.

Now, here's the caveat. I have read @ABataev's

Well, I think it would be good to filter out OMPC_flush somehow
because there is no such clause actually, it is a pseudo clause
for better handling of the flush directive.

as if that clause is pseudo clause that only exists for the sole
purpose of simplifying the parser. As in, it never reaches AST.

I did not however try to verify that. Too bad, i was wrong.
It absolutely *does* reach AST. Therefore my understanding/justification
for the change was flawed, which makes the patch a regression which must be reverted.

@gribozavr has brought that up again in https://reviews.llvm.org/D57112#inline-521238

...

Sorry to be late for this discussion, but I don't think this conclusion
follows. ASTMatchers are supposed to match the AST as it is.
Even if OMPC_flush is synthetic, it exists in the AST, and users might
want to match it. I think users would find anything else (trying to filter
out AST nodes that are not in the source code) to be surprising. For example,
there's a matcher materializeTemporaryExpr even though this AST node is a
Clang invention and is not a part of the C++ spec.

Matching only constructs that appear in the source code is not feasible with
ASTMatchers, because they are based on Clang's AST that exposes tons of semantic
information, and its design is dictated by the structure of the semantic information.
See "RFC: Tree-based refactorings with Clang" in cfe-dev for a library that will
focus on representing source code as faithfully as possible.

Not to even mention that this code is in ASTTypeTraits, a general library for
handling AST nodes, not specifically for AST Matchers...

[ABataev]

Hmm, do we really need the matches for the AST node that is not described/defined by the standard? If this is really so, I'm ok with this.

[gribozavr]

Hmm, do we really need the matches for the AST node that is not described/defined by the standard? If this is really so, I'm ok with this.

When the rubber meets the road, it does not matter what is in the spec, users will need to work with the ASTs that they get. If there's something in the AST, users will want to match it.

cfe/trunk/include/clang/AST/OpenMPClause.h

 class OMPClauseVisitorBase {
 public:
 #define PTR(CLASS) typename Ptr<CLASS>::type
 #define DISPATCH(CLASS) \
   return static_cast<ImplClass*>(this)->Visit##CLASS(static_cast<PTR(CLASS)>(S))
 
 #define OPENMP_CLAUSE(Name, Class)                              \
   RetTy Visit ## Class (PTR(Class) S) { DISPATCH(Class); }
-  OPENMP_CLAUSE(flush, OMPFlushClause)
 #include "clang/Basic/OpenMPKinds.def"
 
   RetTy Visit(PTR(OMPClause) S) {
     // Top switch clause: visit each OMPClause.
     switch (S->getClauseKind()) {
     default: llvm_unreachable("Unknown clause kind!");
 #define OPENMP_CLAUSE(Name, Class)                              \
     case OMPC_ ## Name : return Visit ## Class(static_cast<PTR(Class)>(S));
-    OPENMP_CLAUSE(flush, OMPFlushClause)
 #include "clang/Basic/OpenMPKinds.def"
     }
   }
   // Base case, ignore it. :)
   RetTy VisitOMPClause(PTR(OMPClause) Node) { return RetTy(); }
 #undef PTR
 #undef DISPATCH
 };
class OMPClausePrinter final : public OMPClauseVisitor<OMPClausePrinter> {
   /// Process clauses with list of variables.
   template <typename T> void VisitOMPClauseList(T *Node, char StartSym);
 
 public:
   OMPClausePrinter(raw_ostream &OS, const PrintingPolicy &Policy)
       : OS(OS), Policy(Policy) {}
 
 #define OPENMP_CLAUSE(Name, Class) void Visit##Class(Class *S);
-  OPENMP_CLAUSE(flush, OMPFlushClause)
 #include "clang/Basic/OpenMPKinds.def"
 };
 
 } // namespace clang
 
 #endif // LLVM_CLANG_AST_OPENMPCLAUSE_H

cfe/trunk/include/clang/AST/RecursiveASTVisitor.h

#undef DEF_TRAVERSE_TMPL_INST
   bool TraverseDeclaratorHelper(DeclaratorDecl *D);
   bool TraverseDeclContextHelper(DeclContext *DC);
   bool TraverseFunctionHelper(FunctionDecl *D);
   bool TraverseVarHelper(VarDecl *D);
   bool TraverseOMPExecutableDirective(OMPExecutableDirective *S);
   bool TraverseOMPLoopDirective(OMPLoopDirective *S);
   bool TraverseOMPClause(OMPClause *C);
 #define OPENMP_CLAUSE(Name, Class) bool Visit##Class(Class *C);
-  OPENMP_CLAUSE(flush, OMPFlushClause)
 #include "clang/Basic/OpenMPKinds.def"
   /// Process clauses with list of variables.
   template <typename T> bool VisitOMPClauseList(T *Node);
   /// Process clauses with pre-initis.
   bool VisitOMPClauseWithPreInit(OMPClauseWithPreInit *Node);
   bool VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *Node);
 
   bool dataTraverseNode(Stmt *S, DataRecursionQueue *Queue);

 bool RecursiveASTVisitor<Derived>::TraverseOMPClause(OMPClause *C) {
   if (!C)
     return true;
   switch (C->getClauseKind()) {
 #define OPENMP_CLAUSE(Name, Class)                                             \
   case OMPC_##Name:                                                            \
     TRY_TO(Visit##Class(static_cast<Class *>(C)));                             \
     break;
-  OPENMP_CLAUSE(flush, OMPFlushClause)
 #include "clang/Basic/OpenMPKinds.def"
   case OMPC_threadprivate:
   case OMPC_uniform:
   case OMPC_unknown:
     break;
   }
   return true;
 }

cfe/trunk/include/clang/Basic/OpenMPKinds.h

#include "clang/Basic/OpenMPKinds.def"
   OMPD_unknown
 };
 
 /// OpenMP clauses.
 enum OpenMPClauseKind {
 #define OPENMP_CLAUSE(Name, Class) \
   OMPC_##Name,
 #include "clang/Basic/OpenMPKinds.def"
-  OMPC_flush,
   OMPC_threadprivate,
   OMPC_uniform,
   OMPC_unknown
 };
 
 /// OpenMP attributes for 'default' clause.
 enum OpenMPDefaultClauseKind {
 #define OPENMP_DEFAULT_KIND(Name) \

cfe/trunk/include/clang/Basic/OpenMPKinds.def

 OPENMP_CLAUSE(copyin,  OMPCopyinClause)
 OPENMP_CLAUSE(copyprivate,  OMPCopyprivateClause)
 OPENMP_CLAUSE(proc_bind, OMPProcBindClause)
 OPENMP_CLAUSE(schedule, OMPScheduleClause)
 OPENMP_CLAUSE(ordered, OMPOrderedClause)
 OPENMP_CLAUSE(nowait, OMPNowaitClause)
 OPENMP_CLAUSE(untied, OMPUntiedClause)
 OPENMP_CLAUSE(mergeable, OMPMergeableClause)
+OPENMP_CLAUSE(flush, OMPFlushClause)
 OPENMP_CLAUSE(read, OMPReadClause)
 OPENMP_CLAUSE(write, OMPWriteClause)
 OPENMP_CLAUSE(update, OMPUpdateClause)
 OPENMP_CLAUSE(capture, OMPCaptureClause)
 OPENMP_CLAUSE(seq_cst, OMPSeqCstClause)
 OPENMP_CLAUSE(depend, OMPDependClause)
 OPENMP_CLAUSE(device, OMPDeviceClause)
 OPENMP_CLAUSE(threads, OMPThreadsClause)

cfe/trunk/include/clang/Serialization/ASTReader.h

class OMPClauseReader : public OMPClauseVisitor<OMPClauseReader> {
   ASTRecordReader &Record;
   ASTContext &Context;
 
 public:
   OMPClauseReader(ASTRecordReader &Record)
       : Record(Record), Context(Record.getContext()) {}
 
 #define OPENMP_CLAUSE(Name, Class) void Visit##Class(Class *C);
-  OPENMP_CLAUSE(flush, OMPFlushClause)
 #include "clang/Basic/OpenMPKinds.def"
   OMPClause *readClause();
   void VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C);
   void VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C);
 };
 
 } // namespace clang
 
 #endif // LLVM_CLANG_SERIALIZATION_ASTREADER_H

cfe/trunk/include/clang/Serialization/ASTWriter.h

 };
 
 class OMPClauseWriter : public OMPClauseVisitor<OMPClauseWriter> {
   ASTRecordWriter &Record;
 
 public:
   OMPClauseWriter(ASTRecordWriter &Record) : Record(Record) {}
 #define OPENMP_CLAUSE(Name, Class) void Visit##Class(Class *S);
-  OPENMP_CLAUSE(flush, OMPFlushClause)
 #include "clang/Basic/OpenMPKinds.def"
   void writeClause(OMPClause *C);
   void VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C);
   void VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C);
 };
 
 } // namespace clang
 
 #endif // LLVM_CLANG_SERIALIZATION_ASTWRITER_H

cfe/trunk/lib/AST/OpenMPClause.cpp

 
 OMPClause::child_range OMPClause::children() {
   switch (getClauseKind()) {
   default:
     break;
 #define OPENMP_CLAUSE(Name, Class)                                             \
   case OMPC_##Name:                                                            \
     return static_cast<Class *>(this)->children();
-  OPENMP_CLAUSE(flush, OMPFlushClause)
 #include "clang/Basic/OpenMPKinds.def"
   }
   llvm_unreachable("unknown OMPClause");
 }
 
 OMPClauseWithPreInit *OMPClauseWithPreInit::get(OMPClause *C) {
   auto *Res = OMPClauseWithPreInit::get(const_cast<const OMPClause *>(C));
   return Res ? const_cast<OMPClauseWithPreInit *>(Res) : nullptr;

cfe/trunk/lib/AST/StmtProfile.cpp

class OMPClauseProfiler : public ConstOMPClauseVisitor<OMPClauseProfiler> {
   /// Process clauses with list of variables.
   template <typename T>
   void VisitOMPClauseList(T *Node);
 
 public:
   OMPClauseProfiler(StmtProfiler *P) : Profiler(P) { }
 #define OPENMP_CLAUSE(Name, Class)                                             \
   void Visit##Class(const Class *C);
-  OPENMP_CLAUSE(flush, OMPFlushClause)
 #include "clang/Basic/OpenMPKinds.def"
   void VistOMPClauseWithPreInit(const OMPClauseWithPreInit *C);
   void VistOMPClauseWithPostUpdate(const OMPClauseWithPostUpdate *C);
 };
 
 void OMPClauseProfiler::VistOMPClauseWithPreInit(
     const OMPClauseWithPreInit *C) {
   if (auto *S = C->getPreInitStmt())

cfe/trunk/lib/Basic/OpenMPKinds.cpp

const char *clang::getOpenMPClauseName(OpenMPClauseKind Kind) {
   assert(Kind <= OMPC_unknown);
   switch (Kind) {
   case OMPC_unknown:
     return "unknown";
 #define OPENMP_CLAUSE(Name, Class)                                             \
   case OMPC_##Name:                                                            \
     return #Name;
 #include "clang/Basic/OpenMPKinds.def"
-  case OMPC_flush:
-    return "flush";
   case OMPC_uniform:
     return "uniform";
   case OMPC_threadprivate:
     return "threadprivate or thread local";
   }
   llvm_unreachable("Invalid OpenMP clause kind");
 }
 

cfe/trunk/lib/Sema/TreeTransform.h

#define EXPR(Node, Parent)                        \
   LLVM_ATTRIBUTE_NOINLINE \
   ExprResult Transform##Node(Node *E);
 #define ABSTRACT_STMT(Stmt)
 #include "clang/AST/StmtNodes.inc"
 
 #define OPENMP_CLAUSE(Name, Class)                        \
   LLVM_ATTRIBUTE_NOINLINE \
   OMPClause *Transform ## Class(Class *S);
-  OPENMP_CLAUSE(flush, OMPFlushClause)
 #include "clang/Basic/OpenMPKinds.def"
 
   /// Build a new qualified type given its unqualified type and type location.
   ///
   /// By default, this routine adds type qualifiers only to types that can
   /// have qualifiers, and silently suppresses those qualifiers that are not
   /// permitted. Subclasses may override this routine to provide different
   /// behavior.
if (!S)
     return S;
 
   switch (S->getClauseKind()) {
   default: break;
   // Transform individual clause nodes
 #define OPENMP_CLAUSE(Name, Class)                                             \
   case OMPC_ ## Name :                                                         \
     return getDerived().Transform ## Class(cast<Class>(S));
-  OPENMP_CLAUSE(flush, OMPFlushClause)
 #include "clang/Basic/OpenMPKinds.def"
   }
 
   return S;
 }
 
 
 template<typename Derived>

cfe/trunk/tools/libclang/CIndex.cpp

class OMPClauseEnqueue : public ConstOMPClauseVisitor<OMPClauseEnqueue> {
   EnqueueVisitor *Visitor;
   /// Process clauses with list of variables.
   template <typename T>
   void VisitOMPClauseList(T *Node);
 public:
   OMPClauseEnqueue(EnqueueVisitor *Visitor) : Visitor(Visitor) { }
 #define OPENMP_CLAUSE(Name, Class)                                             \
   void Visit##Class(const Class *C);
-  OPENMP_CLAUSE(flush, OMPFlushClause)
 #include "clang/Basic/OpenMPKinds.def"
   void VisitOMPClauseWithPreInit(const OMPClauseWithPreInit *C);
   void VisitOMPClauseWithPostUpdate(const OMPClauseWithPostUpdate *C);
 };
 
 void OMPClauseEnqueue::VisitOMPClauseWithPreInit(
     const OMPClauseWithPreInit *C) {
   Visitor->AddStmt(C->getPreInitStmt());