[OPENMP]Fix PR46357: Do not allow types declarations in pragmas.

[ABataev]

Summary

Compiler may erroneously treat current context in OpenMP pragmas as the
context where new type declaration/definition is allowed. But the
declartation/definition of the new types in OpenMP pragmas should not be
allowed.

[jdoerfert]

Hm, does the standard say this is not allowed? I can see that we don't want it but I'm not 100% certain here.

[ABataev]

In D82019#2098509, @jdoerfert wrote:

Hm, does the standard say this is not allowed? I can see that we don't want it but I'm not 100% certain here.

It does not say anything specific, but I don't think it is a good idea to declare a new type in the OpenMP directive. But you can still declare a new type in the structured block.

[jdoerfert]

I agree it is not a good idea. Let's hope no one will complain :) LGTM.

clang/include/clang/Parse/RAIIObjectsForParser.h

namespace clang {
 
   /// Activates OpenMP parsing mode to preseve OpenMP specific annotation
   /// tokens.
   class ParsingOpenMPDirectiveRAII {
     Parser &P;
     bool OldVal;
 
   public:
-    ParsingOpenMPDirectiveRAII(Parser &P)
+    ParsingOpenMPDirectiveRAII(Parser &P, bool Value = true)
         : P(P), OldVal(P.OpenMPDirectiveParsing) {
-      P.OpenMPDirectiveParsing = true;
+      P.OpenMPDirectiveParsing = Value;
     }
 
     /// This can be used to restore the state early, before the dtor
     /// is run.
     void restore() { P.OpenMPDirectiveParsing = OldVal; }
 
     ~ParsingOpenMPDirectiveRAII() { restore(); }
   };

clang/lib/Parse/ParseDeclCXX.cpp

void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind,
   // For these, DSC is DeclSpecContext::DSC_type_specifier or
   // DeclSpecContext::DSC_alias_declaration.
 
   // If there are attributes after class name, parse them.
   MaybeParseCXX11Attributes(Attributes);
 
   const PrintingPolicy &Policy = Actions.getASTContext().getPrintingPolicy();
   Sema::TagUseKind TUK;
-  if (isDefiningTypeSpecifierContext(DSC) == AllowDefiningTypeSpec::No)
+  if (isDefiningTypeSpecifierContext(DSC) == AllowDefiningTypeSpec::No ||
+      (getLangOpts().OpenMP && OpenMPDirectiveParsing))
     TUK = Sema::TUK_Reference;
   else if (Tok.is(tok::l_brace) ||
            (getLangOpts().CPlusPlus && Tok.is(tok::colon)) ||
            (isCXX11FinalKeyword() &&
             (NextToken().is(tok::l_brace) || NextToken().is(tok::colon)))) {
     if (DS.isFriendSpecified()) {
       // C++ [class.friend]p2:
       //   A class shall not be defined in a friend declaration.

clang/lib/Parse/ParseOpenMP.cpp

case OMPD_begin_declare_variant: {
     ConsumeToken();
     OMPTraitInfo &TI = Actions.getASTContext().getNewOMPTraitInfo();
     if (parseOMPDeclareVariantMatchClause(Loc, TI))
       break;
 
     // Skip last tokens.
     skipUntilPragmaOpenMPEnd(OMPD_begin_declare_variant);
 
+    ParsingOpenMPDirectiveRAII NormalScope(*this, /*Value=*/false);
+
     VariantMatchInfo VMI;
     ASTContext &ASTCtx = Actions.getASTContext();
     TI.getAsVariantMatchInfo(ASTCtx, VMI);
     OMPContext OMPCtx(ASTCtx.getLangOpts().OpenMPIsDevice,
                       ASTCtx.getTargetInfo().getTriple());
 
     if (isVariantApplicableInContext(VMI, OMPCtx, /* DeviceSetOnly */ true)) {
       Actions.ActOnOpenMPBeginDeclareVariant(Loc, TI);
case OMPD_declare_target: {
     }
 
     // Skip the last annot_pragma_openmp_end.
     ConsumeAnyToken();
 
     if (!Actions.ActOnStartOpenMPDeclareTargetDirective(DTLoc))
       return DeclGroupPtrTy();
 
+    ParsingOpenMPDirectiveRAII NormalScope(*this, /*Value=*/false);
     llvm::SmallVector<Decl *, 4>  Decls;
     DKind = parseOpenMPDirectiveKind(*this);
     while (DKind != OMPD_end_declare_target && Tok.isNot(tok::eof) &&
            Tok.isNot(tok::r_brace)) {
       DeclGroupPtrTy Ptr;
       // Here we expect to see some function declaration.
       if (AS == AS_none) {
         assert(TagType == DeclSpec::TST_unspecified);
case OMPD_target_teams_distribute_simd: {
 
     StmtResult AssociatedStmt;
     if (HasAssociatedStatement) {
       // The body is a block scope like in Lambdas and Blocks.
       Actions.ActOnOpenMPRegionStart(DKind, getCurScope());
       // FIXME: We create a bogus CompoundStmt scope to hold the contents of
       // the captured region. Code elsewhere assumes that any FunctionScopeInfo
       // should have at least one compound statement scope within it.
+      ParsingOpenMPDirectiveRAII NormalScope(*this, /*Value=*/false);
       AssociatedStmt = (Sema::CompoundScopeRAII(Actions), ParseStatement());
       AssociatedStmt = Actions.ActOnOpenMPRegionEnd(AssociatedStmt, Clauses);
     } else if (DKind == OMPD_target_update || DKind == OMPD_target_enter_data ||
                DKind == OMPD_target_exit_data) {
       Actions.ActOnOpenMPRegionStart(DKind, getCurScope());
       AssociatedStmt = (Sema::CompoundScopeRAII(Actions),
                         Actions.ActOnCompoundStmt(Loc, Loc, llvm::None,
                                                   /*isStmtExpr=*/false));

clang/test/OpenMP/declare_reduction_ast_print.cpp

 
 template <typename T>
 void bar(T &x, T &y) { x.a += y.a; }
 
 namespace N1
 {
   struct A { int a; A() : a(0) {} };
   #pragma omp declare reduction(+: A : bar(omp_out, omp_in))
-};
+  #pragma omp declare reduction(-: struct A : bar(omp_out, omp_in))
+}
+// CHECK: namespace N1 {
+// CHECK: #pragma omp declare reduction (+ : N1::A : bar(omp_out, omp_in))
+// CHECK: #pragma omp declare reduction (- : struct A : bar(omp_out, omp_in))
 
 #pragma omp declare reduction(+ : int, char : omp_out *= omp_in)
 // CHECK: #pragma omp declare reduction (+ : int : omp_out *= omp_in){{$}}
 // CHECK-NEXT: #pragma omp declare reduction (+ : char : omp_out *= omp_in)
 
 
 template <class T>
 class SSS {