[tblgen][directive] Fix clause parser generation for list value

[clementval]

Summary

The clause parser generation was not taking into account the
isValueList flag. This patch updates the emitter to generate
the correct code.

[razvanlupusoru]

Solution looks good to me. The name suffix of "c" is not too informative - but seems it was already suffixed with other letters. So approach seems reasonable to me.

llvm/test/TableGen/directive1.td

 }
 
 def TDLC_ClauseB : Clause<"clauseb"> {
   let flangClass = "IntExpr";
   let isValueOptional = 1;
   let isDefault = 1;
 }
 
+def TDLC_ClauseC : Clause<"clausec"> {
+  let flangClass = "IntExpr";
+  let isValueList = 1;
+}
+
 def TDL_DirA : Directive<"dira"> {
   let allowedClauses = [
     VersionedClause<TDLC_ClauseA>,
     VersionedClause<TDLC_ClauseB>
   ];
   let isDefault = 1;
 }
 

 // CHECK-EMPTY:
 // CHECK-NEXT:  static constexpr std::size_t Directive_enumSize = 1;
 // CHECK-EMPTY:
 // CHECK-NEXT:  constexpr auto TDLD_dira = llvm::tdl::Directive::TDLD_dira;
 // CHECK-EMPTY:
 // CHECK-NEXT:  enum class Clause {
 // CHECK-NEXT:    TDLC_clausea,
 // CHECK-NEXT:    TDLC_clauseb,
+// CHECK-NEXT:    TDLC_clausec,
 // CHECK-NEXT:  };
 // CHECK-EMPTY:
-// CHECK-NEXT:  static constexpr std::size_t Clause_enumSize = 2;
+// CHECK-NEXT:  static constexpr std::size_t Clause_enumSize = 3;
 // CHECK-EMPTY:
 // CHECK-NEXT:  constexpr auto TDLC_clausea = llvm::tdl::Clause::TDLC_clausea;
 // CHECK-NEXT:  constexpr auto TDLC_clauseb = llvm::tdl::Clause::TDLC_clauseb;
+// CHECK-NEXT:  constexpr auto TDLC_clausec = llvm::tdl::Clause::TDLC_clausec;
 // CHECK-EMPTY:
 // CHECK-NEXT:  enum class AKind {
 // CHECK-NEXT:    TDLCV_vala=1,
 // CHECK-NEXT:    TDLCV_valb=2,
 // CHECK-NEXT:    TDLCV_valc=3,
 // CHECK-NEXT:  };
 // CHECK-EMPTY:
 // CHECK-NEXT:  constexpr auto TDLCV_vala = llvm::tdl::AKind::TDLCV_vala;

 // IMPL-EMPTY:
 // IMPL-NEXT:  #endif // GEN_FLANG_DIRECTIVE_CLAUSE_MAP
 // IMPL-EMPTY:
 // IMPL-NEXT:  #ifdef GEN_FLANG_CLAUSE_PARSER_CLASSES
 // IMPL-NEXT:  #undef GEN_FLANG_CLAUSE_PARSER_CLASSES
 // IMPL-EMPTY:
 // IMPL-NEXT:  EMPTY_CLASS(Clausea);
 // IMPL-NEXT:  WRAPPER_CLASS(Clauseb, std::optional<IntExpr>);
+// IMPL-NEXT:  WRAPPER_CLASS(Clausec, std::list<IntExpr>);
 // IMPL-EMPTY:
 // IMPL-NEXT:  #endif // GEN_FLANG_CLAUSE_PARSER_CLASSES
 // IMPL-EMPTY:
 // IMPL-NEXT:  #ifdef GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST
 // IMPL-NEXT:  #undef GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST
 // IMPL-EMPTY:
 // IMPL-NEXT:  Clausea
 // IMPL-NEXT:  , Clauseb
+// IMPL-NEXT:  , Clausec
 // IMPL-EMPTY:
 // IMPL-NEXT:  #endif // GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST
 // IMPL-EMPTY:
 // IMPL-NEXT:  #ifdef GEN_FLANG_DUMP_PARSE_TREE_CLAUSES
 // IMPL-NEXT:  #undef GEN_FLANG_DUMP_PARSE_TREE_CLAUSES
 // IMPL-EMPTY:
 // IMPL-NEXT:  NODE(TdlClause, Clausea)
 // IMPL-NEXT:  NODE(TdlClause, Clauseb)
+// IMPL-NEXT:  NODE(TdlClause, Clausec)
 // IMPL-EMPTY:
 // IMPL-NEXT:  #endif // GEN_FLANG_DUMP_PARSE_TREE_CLAUSES
 // IMPL-EMPTY:
 // IMPL-NEXT:  #ifdef GEN_FLANG_CLAUSE_UNPARSE
 // IMPL-NEXT:  #undef GEN_FLANG_CLAUSE_UNPARSE
 // IMPL-EMPTY:
 // IMPL-NEXT:  void Before(const TdlClause::Clausea &) { Word("CLAUSEA"); }
 // IMPL-NEXT:  void Unparse(const TdlClause::Clauseb &x) {
 // IMPL-NEXT:    Word("CLAUSEB");
 // IMPL-NEXT:    Walk("(", x.v, ")");
 // IMPL-NEXT:  }
+// IMPL-NEXT:  void Unparse(const TdlClause::Clausec &x) {
+// IMPL-NEXT:    Word("CLAUSEC");
+// IMPL-NEXT:    Put("(");
+// IMPL-NEXT:    Walk(x.v, ",");
+// IMPL-NEXT:    Put(")");
+// IMPL-NEXT:  }
 // IMPL-EMPTY:
 // IMPL-NEXT:  #endif // GEN_FLANG_CLAUSE_UNPARSE
 // IMPL-EMPTY:
 // IMPL-NEXT:  #ifdef GEN_FLANG_CLAUSE_CHECK_ENTER
 // IMPL-NEXT:  #undef GEN_FLANG_CLAUSE_CHECK_ENTER
 // IMPL-EMPTY:
 // IMPL-NEXT:  void Enter(const parser::TdlClause::Clausea &);
 // IMPL-NEXT:  void Enter(const parser::TdlClause::Clauseb &);
+// IMPL-NEXT:  void Enter(const parser::TdlClause::Clausec &);
 // IMPL-EMPTY:
 // IMPL-NEXT:  #endif // GEN_FLANG_CLAUSE_CHECK_ENTER
 // IMPL-EMPTY:
 // IMPL-NEXT:  #ifdef GEN_FLANG_CLAUSE_PARSER_KIND_MAP
 // IMPL-NEXT:  #undef GEN_FLANG_CLAUSE_PARSER_KIND_MAP
 // IMPL-EMPTY:
 // IMPL-NEXT:  if constexpr (std::is_same_v<A, parser::TdlClause::Clausea>)
 // IMPL-NEXT:    return llvm::tdl::Clause::TDLC_clausea;
 // IMPL-NEXT:  if constexpr (std::is_same_v<A, parser::TdlClause::Clauseb>)
 // IMPL-NEXT:    return llvm::tdl::Clause::TDLC_clauseb;
+// IMPL-NEXT:  if constexpr (std::is_same_v<A, parser::TdlClause::Clausec>)
+// IMPL-NEXT:    return llvm::tdl::Clause::TDLC_clausec;
 // IMPL-NEXT:  llvm_unreachable("Invalid Tdl Parser clause");
 // IMPL-EMPTY:
 // IMPL-NEXT:  #endif // GEN_FLANG_CLAUSE_PARSER_KIND_MAP
 // IMPL-EMPTY:
 // IMPL-NEXT: #ifdef GEN_FLANG_CLAUSES_PARSER
 // IMPL-NEXT: #undef GEN_FLANG_CLAUSES_PARSER
 // IMPL-EMPTY:
 // IMPL-NEXT:  TYPE_PARSER(
+// IMPL-NEXT:    "clausec" >> construct<TdlClause>(construct<TdlClause::Clausec>(parenthesized(nonemptyList(Parser<IntExpr>{})))) || 
 // IMPL-NEXT:    "clauseb" >> construct<TdlClause>(construct<TdlClause::Clauseb>(maybe(parenthesized(Parser<IntExpr>{})))) ||
 // IMPL-NEXT:    "clausea" >> construct<TdlClause>(construct<TdlClause::Clausea>())
 // IMPL-NEXT:  )
 // IMPL-EMPTY:
 // IMPL-NEXT:  #endif // GEN_FLANG_CLAUSES_PARSER
 // IMPL-EMPTY:
 // IMPL-NEXT:  #ifdef GEN_CLANG_CLAUSE_CLASS
 // IMPL-NEXT:  #undef GEN_CLANG_CLAUSE_CLASS

 // IMPL-NEXT:    CLAUSE(TDLC_##Name, Str, /* Implicit */ true)    \
 // IMPL-NEXT:    CLAUSE_CLASS(TDLC_##Name, Str, Class)
 // IMPL-NEXT:  #define __IMPLICIT_CLAUSE_NO_CLASS(Name, Str)      \
 // IMPL-NEXT:    CLAUSE(TDLC_##Name, Str, /* Implicit */ true)    \
 // IMPL-NEXT:    CLAUSE_NO_CLASS(TDLC_##Name, Str)
 // IMPL-EMPTY:
 // IMPL-NEXT:  __CLAUSE_NO_CLASS(clausea)
 // IMPL-NEXT:  __CLAUSE_NO_CLASS(clauseb)
+// IMPL-NEXT:  __CLAUSE_NO_CLASS(clausec)
 // IMPL-EMPTY:
 // IMPL-NEXT:  #undef __IMPLICIT_CLAUSE_NO_CLASS
 // IMPL-NEXT:  #undef __IMPLICIT_CLAUSE_CLASS
 // IMPL-NEXT:  #undef __CLAUSE
 // IMPL-NEXT:  #undef CLAUSE_NO_CLASS
 // IMPL-NEXT:  #undef CLAUSE_CLASS
 // IMPL-NEXT:  #undef CLAUSE
 // IMPL-EMPTY:

 // IMPL-NEXT:    }
 // IMPL-NEXT:    llvm_unreachable("Invalid Tdl Directive kind");
 // IMPL-NEXT:  }
 // IMPL-EMPTY:
 // IMPL-NEXT:  Clause llvm::tdl::getTdlClauseKind(llvm::StringRef Str) {
 // IMPL-NEXT:    return llvm::StringSwitch<Clause>(Str)
 // IMPL-NEXT:      .Case("clausea",TDLC_clausea)
 // IMPL-NEXT:      .Case("clauseb",TDLC_clauseb)
+// IMPL-NEXT:      .Case("clausec",TDLC_clausec)
 // IMPL-NEXT:      .Default(TDLC_clauseb);
 // IMPL-NEXT:  }
 // IMPL-EMPTY:
 // IMPL-NEXT:  llvm::StringRef llvm::tdl::getTdlClauseName(Clause Kind) {
 // IMPL-NEXT:    switch (Kind) {
 // IMPL-NEXT:      case TDLC_clausea:
 // IMPL-NEXT:        return "clausea";
 // IMPL-NEXT:      case TDLC_clauseb:
 // IMPL-NEXT:        return "clauseb";
+// IMPL-NEXT:      case TDLC_clausec:
+// IMPL-NEXT:        return "clausec";
 // IMPL-NEXT:    }
 // IMPL-NEXT:    llvm_unreachable("Invalid Tdl Clause kind");
 // IMPL-NEXT:  }
 // IMPL-EMPTY:
 // IMPL-NEXT:  AKind llvm::tdl::getAKind(llvm::StringRef Str) {
 // IMPL-NEXT:    return llvm::StringSwitch<AKind>(Str)
 // IMPL-NEXT:      .Case("vala",TDLCV_vala)
 // IMPL-NEXT:      .Case("valb",TDLCV_valb)

llvm/utils/TableGen/DirectiveEmitter.cpp

if (Clause.getFlangClass().empty()) {
       OS << "\n";
       ++index;
       continue;
     }
 
     if (Clause.isValueOptional())
       OS << "maybe(";
     OS << "parenthesized(";
+    if (Clause.isValueList())
+      OS << "nonemptyList(";
 
     if (!Clause.getPrefix().empty())
       OS << "\"" << Clause.getPrefix() << ":\" >> ";
 
     // The common Flang parser are used directly. Their name is identical to
     // the Flang class with first letter as lowercase. If the Flang class is
     // not a common class, we assume there is a specific Parser<>{} with the
     // Flang class name provided.
     llvm::SmallString<128> Scratch;
     StringRef Parser =
         llvm::StringSwitch<StringRef>(Clause.getFlangClass())
             .Case("Name", "name")
             .Case("ScalarIntConstantExpr", "scalarIntConstantExpr")
             .Case("ScalarIntExpr", "scalarIntExpr")
             .Case("ScalarLogicalExpr", "scalarLogicalExpr")
             .Default(("Parser<" + Clause.getFlangClass() + ">{}")
                          .toStringRef(Scratch));
     OS << Parser;
     if (!Clause.getPrefix().empty() && Clause.isPrefixOptional())
       OS << " || " << Parser;
+    if (Clause.isValueList()) // close nonemptyList(.
+      OS << ")";
     OS << ")"; // close parenthesized(.
 
     if (Clause.isValueOptional()) // close maybe(.
       OS << ")";
     OS << "))";
     if (index != lastClauseIndex)
       OS << " ||";
     OS << "\n";