Address feedback

clang/include/clang/Sema/SemaOpenACC.h

@@ -6,7 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 /// \file
-/// This file implements semantic analysis for OpenACC constructs and
+/// This file declares semantic analysis for OpenACC constructs and
 /// clauses.
 ///
 //===----------------------------------------------------------------------===//
@@ -23,46 +23,43 @@ class Sema;
 
 class SemaOpenACC {
 public:
+  SemaOpenACC(Sema &S);
+
   Sema &Sema;
 
   /// Called after parsing an OpenACC Clause so that it can be checked.
-  bool ActOnOpenACCClause(OpenACCClauseKind ClauseKind,
-                          SourceLocation StartLoc);
+  bool ActOnClause(OpenACCClauseKind ClauseKind, SourceLocation StartLoc);
 
   /// Called after the construct has been parsed, but clauses haven't been
   /// parsed.  This allows us to diagnose not-implemented, as well as set up any
   /// state required for parsing the clauses.
-  void ActOnOpenACCConstruct(OpenACCDirectiveKind K, SourceLocation StartLoc);
+  void ActOnConstruct(OpenACCDirectiveKind K, SourceLocation StartLoc);
 
   /// Called after the directive, including its clauses, have been parsed and
   /// parsing has consumed the 'annot_pragma_openacc_end' token. This DOES
   /// happen before any associated declarations or statements have been parsed.
   /// This function is only called when we are parsing a 'statement' context.
-  bool ActOnStartOpenACCStmtDirective(OpenACCDirectiveKind K,
-                                      SourceLocation StartLoc);
+  bool ActOnStartStmtDirective(OpenACCDirectiveKind K, SourceLocation StartLoc);
 
   /// Called after the directive, including its clauses, have been parsed and
   /// parsing has consumed the 'annot_pragma_openacc_end' token. This DOES
   /// happen before any associated declarations or statements have been parsed.
   /// This function is only called when we are parsing a 'Decl' context.
-  bool ActOnStartOpenACCDeclDirective(OpenACCDirectiveKind K,
-                                      SourceLocation StartLoc);
+  bool ActOnStartDeclDirective(OpenACCDirectiveKind K, SourceLocation StartLoc);
   /// Called when we encounter an associated statement for our construct, this
   /// should check legality of the statement as it appertains to this Construct.
-  StmtResult ActOnOpenACCAssociatedStmt(OpenACCDirectiveKind K,
-                                        StmtResult AssocStmt);
+  StmtResult ActOnAssociatedStmt(OpenACCDirectiveKind K, StmtResult AssocStmt);
 
   /// Called after the directive has been completely parsed, including the
   /// declaration group or associated statement.
-  StmtResult ActOnEndOpenACCStmtDirective(OpenACCDirectiveKind K,
-                                          SourceLocation StartLoc,
-                                          SourceLocation EndLoc,
-                                          StmtResult AssocStmt);
+  StmtResult ActOnEndStmtDirective(OpenACCDirectiveKind K,
+                                   SourceLocation StartLoc,
+                                   SourceLocation EndLoc, StmtResult AssocStmt);
   /// Called after the directive has been completely parsed, including the
   /// declaration group or associated statement.
-  DeclGroupRef ActOnEndOpenACCDeclDirective();
+  DeclGroupRef ActOnEndDeclDirective();
 };
 
 } // namespace clang
 
-#endif // LLVM_CLANG_SEMA_SEMAOPENACC_H
+#endif // LLVM_CLANG_SEMA_SEMAOPENACC_H

clang/lib/Parse/ParseOpenACC.cpp

@@ -778,7 +778,7 @@ bool Parser::ParseOpenACCClause(OpenACCDirectiveKind DirKind) {
   SourceLocation ClauseLoc = ConsumeToken();
 
   bool Result = ParseOpenACCClauseParams(DirKind, Kind);
-  getActions().OpenACC.ActOnOpenACCClause(Kind, ClauseLoc);
+  getActions().OpenACC.ActOnClause(Kind, ClauseLoc);
   return Result;
 }
 
@@ -1152,7 +1152,7 @@ Parser::OpenACCDirectiveParseInfo Parser::ParseOpenACCDirective() {
   SourceLocation StartLoc = getCurToken().getLocation();
   OpenACCDirectiveKind DirKind = ParseOpenACCDirectiveKind(*this);
 
-  getActions().OpenACC.ActOnOpenACCConstruct(DirKind, StartLoc);
+  getActions().OpenACC.ActOnConstruct(DirKind, StartLoc);
 
   // Once we've parsed the construct/directive name, some have additional
   // specifiers that need to be taken care of. Atomic has an 'atomic-clause'
@@ -1224,13 +1224,12 @@ Parser::DeclGroupPtrTy Parser::ParseOpenACCDirectiveDecl() {
 
   OpenACCDirectiveParseInfo DirInfo = ParseOpenACCDirective();
 
-  if (getActions().OpenACC.ActOnStartOpenACCDeclDirective(DirInfo.DirKind,
-                                                          DirInfo.StartLoc))
+  if (getActions().OpenACC.ActOnStartDeclDirective(DirInfo.DirKind,
+                                                   DirInfo.StartLoc))
     return nullptr;
 
   // TODO OpenACC: Do whatever decl parsing is required here.
-  return DeclGroupPtrTy::make(
-      getActions().OpenACC.ActOnEndOpenACCDeclDirective());
+  return DeclGroupPtrTy::make(getActions().OpenACC.ActOnEndDeclDirective());
 }
 
 // Parse OpenACC Directive on a Statement.
@@ -1241,8 +1240,8 @@ StmtResult Parser::ParseOpenACCDirectiveStmt() {
   ConsumeAnnotationToken();
 
   OpenACCDirectiveParseInfo DirInfo = ParseOpenACCDirective();
-  if (getActions().OpenACC.ActOnStartOpenACCStmtDirective(DirInfo.DirKind,
-                                                          DirInfo.StartLoc))
+  if (getActions().OpenACC.ActOnStartStmtDirective(DirInfo.DirKind,
+                                                   DirInfo.StartLoc))
     return StmtError();
 
   StmtResult AssocStmt;
@@ -1251,10 +1250,10 @@ StmtResult Parser::ParseOpenACCDirectiveStmt() {
     ParsingOpenACCDirectiveRAII DirScope(*this, /*Value=*/false);
     ParseScope ACCScope(this, getOpenACCScopeFlags(DirInfo.DirKind));
 
-    AssocStmt = getActions().OpenACC.ActOnOpenACCAssociatedStmt(
-        DirInfo.DirKind, ParseStatement());
+    AssocStmt = getActions().OpenACC.ActOnAssociatedStmt(DirInfo.DirKind,
+                                                         ParseStatement());
   }
 
-  return getActions().OpenACC.ActOnEndOpenACCStmtDirective(
+  return getActions().OpenACC.ActOnEndStmtDirective(
       DirInfo.DirKind, DirInfo.StartLoc, DirInfo.EndLoc, AssocStmt);
 }

clang/lib/Sema/Sema.cpp

@@ -196,7 +196,7 @@ Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
       ThreadSafetyDeclCache(nullptr), LateTemplateParser(nullptr),
       LateTemplateParserCleanup(nullptr), OpaqueParser(nullptr),
       CurContext(nullptr), ExternalSource(nullptr), CurScope(nullptr),
-      Ident_super(nullptr), OpenACCPtr(new SemaOpenACC{*this}),
+      Ident_super(nullptr), OpenACCPtr(std::make_unique<SemaOpenACC>(*this)),
       OpenACC(*OpenACCPtr),
       MSPointerToMemberRepresentationMethod(
           LangOpts.getMSPointerToMemberRepresentationMethod()),

clang/lib/Sema/SemaOpenACC.cpp

@@ -39,8 +39,10 @@ bool diagnoseConstructAppertainment(SemaOpenACC &S, OpenACCDirectiveKind K,
 }
 } // namespace
 
-bool SemaOpenACC::ActOnOpenACCClause(OpenACCClauseKind ClauseKind,
-                                     SourceLocation StartLoc) {
+SemaOpenACC::SemaOpenACC(class Sema &S) : Sema(S) {}
+
+bool SemaOpenACC::ActOnClause(OpenACCClauseKind ClauseKind,
+                              SourceLocation StartLoc) {
   if (ClauseKind == OpenACCClauseKind::Invalid)
     return false;
   // For now just diagnose that it is unsupported and leave the parsing to do
@@ -49,8 +51,8 @@ bool SemaOpenACC::ActOnOpenACCClause(OpenACCClauseKind ClauseKind,
   // success.
   return Sema.Diag(StartLoc, diag::warn_acc_clause_unimplemented) << ClauseKind;
 }
-void SemaOpenACC::ActOnOpenACCConstruct(OpenACCDirectiveKind K,
-                                        SourceLocation StartLoc) {
+void SemaOpenACC::ActOnConstruct(OpenACCDirectiveKind K,
+                                 SourceLocation StartLoc) {
   switch (K) {
   case OpenACCDirectiveKind::Invalid:
     // Nothing to do here, an invalid kind has nothing we can check here.  We
@@ -70,15 +72,15 @@ void SemaOpenACC::ActOnOpenACCConstruct(OpenACCDirectiveKind K,
   }
 }
 
-bool SemaOpenACC::ActOnStartOpenACCStmtDirective(OpenACCDirectiveKind K,
-                                                 SourceLocation StartLoc) {
+bool SemaOpenACC::ActOnStartStmtDirective(OpenACCDirectiveKind K,
+                                          SourceLocation StartLoc) {
   return diagnoseConstructAppertainment(*this, K, StartLoc, /*IsStmt=*/true);
 }
 
-StmtResult SemaOpenACC::ActOnEndOpenACCStmtDirective(OpenACCDirectiveKind K,
-                                                     SourceLocation StartLoc,
-                                                     SourceLocation EndLoc,
-                                                     StmtResult AssocStmt) {
+StmtResult SemaOpenACC::ActOnEndStmtDirective(OpenACCDirectiveKind K,
+                                              SourceLocation StartLoc,
+                                              SourceLocation EndLoc,
+                                              StmtResult AssocStmt) {
   switch (K) {
   default:
     return StmtEmpty();
@@ -94,8 +96,8 @@ StmtResult SemaOpenACC::ActOnEndOpenACCStmtDirective(OpenACCDirectiveKind K,
   llvm_unreachable("Unhandled case in directive handling?");
 }
 
-StmtResult SemaOpenACC::ActOnOpenACCAssociatedStmt(OpenACCDirectiveKind K,
-                                                   StmtResult AssocStmt) {
+StmtResult SemaOpenACC::ActOnAssociatedStmt(OpenACCDirectiveKind K,
+                                            StmtResult AssocStmt) {
   switch (K) {
   default:
     llvm_unreachable("Unimplemented associated statement application");
@@ -116,11 +118,9 @@ StmtResult SemaOpenACC::ActOnOpenACCAssociatedStmt(OpenACCDirectiveKind K,
   llvm_unreachable("Invalid associated statement application");
 }
 
-bool SemaOpenACC::ActOnStartOpenACCDeclDirective(OpenACCDirectiveKind K,
-                                                 SourceLocation StartLoc) {
+bool SemaOpenACC::ActOnStartDeclDirective(OpenACCDirectiveKind K,
+                                          SourceLocation StartLoc) {
   return diagnoseConstructAppertainment(*this, K, StartLoc, /*IsStmt=*/false);
 }
 
-DeclGroupRef SemaOpenACC::ActOnEndOpenACCDeclDirective() {
-  return DeclGroupRef{};
-}
+DeclGroupRef SemaOpenACC::ActOnEndDeclDirective() { return DeclGroupRef{}; }

clang/lib/Sema/TreeTransform.h

@@ -4001,16 +4001,16 @@ class TreeTransform {
                                             SourceLocation BeginLoc,
                                             SourceLocation EndLoc,
                                             StmtResult StrBlock) {
-    getSema().OpenACC.ActOnOpenACCConstruct(K, BeginLoc);
+    getSema().OpenACC.ActOnConstruct(K, BeginLoc);
 
     // TODO OpenACC: Include clauses.
-    if (getSema().OpenACC.ActOnStartOpenACCStmtDirective(K, BeginLoc))
+    if (getSema().OpenACC.ActOnStartStmtDirective(K, BeginLoc))
       return StmtError();
 
-    StrBlock = getSema().OpenACC.ActOnOpenACCAssociatedStmt(K, StrBlock);
+    StrBlock = getSema().OpenACC.ActOnAssociatedStmt(K, StrBlock);
 
-    return getSema().OpenACC.ActOnEndOpenACCStmtDirective(K, BeginLoc, EndLoc,
-                                                          StrBlock);
+    return getSema().OpenACC.ActOnEndStmtDirective(K, BeginLoc, EndLoc,
+                                                   StrBlock);
   }
 
 private: