[OpenACC] Implement 'cache' construct AST/Sema

This statement level construct takes no clauses and has no associated
statement, and simply labels a number of array elements as valid for
caching. The implementation here is pretty simple, but it is a touch of
a special case for parsing, so the parsing code reflects that.

Author: erichkeane

clang/include/clang-c/Index.h

@@ -2214,7 +2214,11 @@ enum CXCursorKind {
    */
   CXCursor_OpenACCAtomicConstruct = 332,
 
-  CXCursor_LastStmt = CXCursor_OpenACCAtomicConstruct,
+  /** OpenACC cache Construct.
+   */
+  CXCursor_OpenACCCacheConstruct = 333,
+
+  CXCursor_LastStmt = CXCursor_OpenACCCacheConstruct,
 
   /**
    * Cursor that represents the translation unit itself.

clang/include/clang/AST/RecursiveASTVisitor.h

@@ -4113,6 +4113,10 @@ DEF_TRAVERSE_STMT(OpenACCUpdateConstruct,
                   { TRY_TO(VisitOpenACCClauseList(S->clauses())); })
 DEF_TRAVERSE_STMT(OpenACCAtomicConstruct,
                   { TRY_TO(TraverseOpenACCAssociatedStmtConstruct(S)); })
+DEF_TRAVERSE_STMT(OpenACCCacheConstruct, {
+  for (auto *E : S->getVarList())
+    TRY_TO(TraverseStmt(E));
+})
 
 // Traverse HLSL: Out argument expression
 DEF_TRAVERSE_STMT(HLSLOutArgExpr, {})

clang/include/clang/AST/StmtOpenACC.h

@@ -593,6 +593,81 @@ class OpenACCWaitConstruct final
   }
 };
 
+class OpenACCCacheConstruct final
+    : public OpenACCConstructStmt,
+      private llvm::TrailingObjects<OpenACCCacheConstruct, Expr *> {
+  friend TrailingObjects;
+  friend class ASTStmtWriter;
+  friend class ASTStmtReader;
+  // Locations of the left and right parens of the 'var-list'
+  // expression-list.
+  SourceRange ParensLoc;
+  SourceLocation ReadOnlyLoc;
+
+  unsigned NumVars = 0;
+
+  OpenACCCacheConstruct(unsigned NumVars)
+      : OpenACCConstructStmt(OpenACCCacheConstructClass,
+                             OpenACCDirectiveKind::Cache, SourceLocation{},
+                             SourceLocation{}, SourceLocation{}),
+        NumVars(NumVars) {
+    std::uninitialized_value_construct(getVarListPtr(),
+                                       getVarListPtr() + NumVars);
+  }
+  OpenACCCacheConstruct(SourceLocation Start, SourceLocation DirectiveLoc,
+                        SourceLocation LParenLoc, SourceLocation ReadOnlyLoc,
+                        ArrayRef<Expr *> VarList, SourceLocation RParenLoc,
+                        SourceLocation End)
+      : OpenACCConstructStmt(OpenACCCacheConstructClass,
+                             OpenACCDirectiveKind::Cache, Start, DirectiveLoc,
+                             End),
+        ParensLoc(LParenLoc, RParenLoc), ReadOnlyLoc(ReadOnlyLoc),
+        NumVars(VarList.size()) {
+
+    std::uninitialized_copy(VarList.begin(), VarList.end(), getVarListPtr());
+  }
+
+  Expr **getVarListPtr() const {
+    return const_cast<Expr **>(getTrailingObjects<Expr *>());
+  }
+
+public:
+  llvm::ArrayRef<Expr *> getVarList() const {
+    return llvm::ArrayRef<Expr *>(getVarListPtr(), NumVars);
+  }
+
+  llvm::ArrayRef<Expr *> getVarList() {
+    return llvm::ArrayRef<Expr *>(getVarListPtr(), NumVars);
+  }
+
+  static bool classof(const Stmt *T) {
+    return T->getStmtClass() == OpenACCCacheConstructClass;
+  }
+
+  static OpenACCCacheConstruct *CreateEmpty(const ASTContext &C,
+                                            unsigned NumVars);
+  static OpenACCCacheConstruct *
+  Create(const ASTContext &C, SourceLocation Start, SourceLocation DirectiveLoc,
+         SourceLocation LParenLoc, SourceLocation ReadOnlyLoc,
+         ArrayRef<Expr *> VarList, SourceLocation RParenLoc,
+         SourceLocation End);
+
+  SourceLocation getLParenLoc() const { return ParensLoc.getBegin(); }
+  SourceLocation getRParenLoc() const { return ParensLoc.getEnd(); }
+  bool hasReadOnly() const { return !ReadOnlyLoc.isInvalid(); }
+  SourceLocation getReadOnlyLoc() const { return ReadOnlyLoc; }
+
+  child_range children() {
+    Stmt **Begin = reinterpret_cast<Stmt **>(getVarListPtr());
+    return child_range(Begin, Begin + NumVars);
+  }
+
+  const_child_range children() const {
+    Stmt *const *Begin = reinterpret_cast<Stmt *const *>(getVarListPtr());
+    return const_child_range(Begin, Begin + NumVars);
+  }
+};
+
 // This class represents an 'init' construct, which has just a clause list.
 class OpenACCInitConstruct final
     : public OpenACCConstructStmt,

clang/include/clang/AST/TextNodeDumper.h

@@ -422,6 +422,7 @@ class TextNodeDumper
   void VisitOpenACCShutdownConstruct(const OpenACCShutdownConstruct *S);
   void VisitOpenACCUpdateConstruct(const OpenACCUpdateConstruct *S);
   void VisitOpenACCAtomicConstruct(const OpenACCAtomicConstruct *S);
+  void VisitOpenACCCacheConstruct(const OpenACCCacheConstruct *S);
   void VisitOpenACCAsteriskSizeExpr(const OpenACCAsteriskSizeExpr *S);
   void VisitOpenACCDeclareDecl(const OpenACCDeclareDecl *D);
   void VisitEmbedExpr(const EmbedExpr *S);

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -12848,6 +12848,9 @@ def err_acc_not_a_var_ref
 def err_acc_not_a_var_ref_use_device_declare
     : Error<"OpenACC variable %select{in 'use_device' clause|on 'declare' "
             "construct}0 is not a valid variable name or array name">;
+def err_acc_not_a_var_ref_cache
+    : Error<"OpenACC variable in cache directive is not a valid sub-array or "
+            "array element">;
 def err_acc_typecheck_subarray_value
     : Error<"OpenACC sub-array subscripted value is not an array or pointer">;
 def err_acc_subarray_function_type

clang/include/clang/Basic/StmtNodes.td

@@ -320,6 +320,7 @@ def OpenACCShutdownConstruct : StmtNode<OpenACCConstructStmt>;
 def OpenACCSetConstruct : StmtNode<OpenACCConstructStmt>;
 def OpenACCUpdateConstruct : StmtNode<OpenACCConstructStmt>;
 def OpenACCAtomicConstruct : StmtNode<OpenACCAssociatedStmtConstruct>;
+def OpenACCCacheConstruct : StmtNode<OpenACCConstructStmt>;
 
 // OpenACC Additional Expressions.
 def OpenACCAsteriskSizeExpr : StmtNode<Expr>;

clang/include/clang/Parse/Parser.h

@@ -3730,6 +3730,11 @@ class Parser : public CodeCompletionHandler {
       return Out;
     }
   };
+  struct OpenACCCacheParseInfo {
+    bool Failed = false;
+    SourceLocation ReadOnlyLoc;
+    SmallVector<Expr *> Vars;
+  };
 
   /// Represents the 'error' state of parsing an OpenACC Clause, and stores
   /// whether we can continue parsing, or should give up on the directive.
@@ -3752,7 +3757,7 @@ class Parser : public CodeCompletionHandler {
   /// Helper that parses an ID Expression based on the language options.
   ExprResult ParseOpenACCIDExpression();
   /// Parses the variable list for the `cache` construct.
-  void ParseOpenACCCacheVarList();
+  OpenACCCacheParseInfo ParseOpenACCCacheVarList();
 
   using OpenACCVarParseResult = std::pair<ExprResult, OpenACCParseCanContinue>;
   /// Parses a single variable in a variable list for OpenACC.

clang/include/clang/Sema/SemaOpenACC.h

@@ -762,6 +762,8 @@ class SemaOpenACC : public SemaBase {
   /// declaration reference to a variable of the correct type.
   ExprResult ActOnVar(OpenACCDirectiveKind DK, OpenACCClauseKind CK,
                       Expr *VarExpr);
+  /// Helper function called by ActonVar that is used to check a 'cache' var.
+  ExprResult ActOnCacheVar(Expr *VarExpr);
 
   // Called after 'ActOnVar' specifically for a 'link' clause, which has to do
   // some minor additional checks.

clang/include/clang/Serialization/ASTBitCodes.h

@@ -2049,6 +2049,7 @@ enum StmtCode {
   STMT_OPENACC_SET_CONSTRUCT,
   STMT_OPENACC_UPDATE_CONSTRUCT,
   STMT_OPENACC_ATOMIC_CONSTRUCT,
+  STMT_OPENACC_CACHE_CONSTRUCT,
 
   // HLSL Constructs
   EXPR_HLSL_OUT_ARG,

clang/lib/AST/StmtOpenACC.cpp

@@ -321,3 +321,21 @@ OpenACCAtomicConstruct *OpenACCAtomicConstruct::Create(
       OpenACCAtomicConstruct(Start, DirectiveLoc, AtKind, End, AssociatedStmt);
   return Inst;
 }
+OpenACCCacheConstruct *OpenACCCacheConstruct::CreateEmpty(const ASTContext &C,
+                                                          unsigned NumVars) {
+  void *Mem =
+      C.Allocate(OpenACCCacheConstruct::totalSizeToAlloc<Expr *>(NumVars));
+  auto *Inst = new (Mem) OpenACCCacheConstruct(NumVars);
+  return Inst;
+}
+
+OpenACCCacheConstruct *OpenACCCacheConstruct::Create(
+    const ASTContext &C, SourceLocation Start, SourceLocation DirectiveLoc,
+    SourceLocation LParenLoc, SourceLocation ReadOnlyLoc,
+    ArrayRef<Expr *> VarList, SourceLocation RParenLoc, SourceLocation End) {
+  void *Mem = C.Allocate(
+      OpenACCCacheConstruct::totalSizeToAlloc<Expr *>(VarList.size()));
+  auto *Inst = new (Mem) OpenACCCacheConstruct(
+      Start, DirectiveLoc, LParenLoc, ReadOnlyLoc, VarList, RParenLoc, End);
+  return Inst;
+}