[PP-EXT] Add support for extended variant creation

Author: kpdev

clang/lib/Parse/ParseDecl.cpp

@@ -4413,6 +4413,38 @@ void Parser::ParseStructDeclaration(
   }
 }
 
+static std::string GetMangledName(const std::string& Base, const std::string& Variant) {
+  return std::string("__pp_struct_")
+          + Base + "__"
+          + Variant;
+}
+
+static std::string GetVariantName(Parser& P, const std::string& CurTokName, const Token& NextTok) {
+  if (!P.getCurToken().is(tok::identifier)) {
+    llvm_unreachable("pp-ext-expected-token-identifier");
+    return "<pp-ext-expected-token-identifier>";
+  }
+
+  std::string MangledName;
+  switch (NextTok.getKind())
+  {
+  case tok::comma:
+  case tok::greater:
+    return CurTokName;
+    break;
+  case tok::less:
+    P.ConsumeToken(); // gen identifier
+    P.ConsumeToken(); // less
+    MangledName = GetMangledName(CurTokName, GetVariantName(P, CurTokName, P.NextToken()));
+    P.ConsumeToken(); // variant identifier
+    return MangledName;
+  default:
+    llvm_unreachable("pp-ext-error-name");
+    break;
+  }
+  return "<pp-ext-error-name>";
+}
+
 Parser::SpecsVec Parser::TryParsePPExt(Decl *TagDecl,
                                        SmallVector<Decl *, 32>& FieldDecls,
                                        const ParsedAttributes& Attrs) {
@@ -4421,27 +4453,28 @@ Parser::SpecsVec Parser::TryParsePPExt(Decl *TagDecl,
     return Result;
   }
 
-  auto DeclGenerator = [&](StringRef Name) {
-    auto* RD = cast<RecordDecl>(TagDecl);
-    auto MangledName = std::string("__pp_struct_")
-            + RD->getDeclName().getAsString() + "__"
-            + Name.str();
-    auto TestName = &PP.getIdentifierTable().get(MangledName);
+  auto DeclGenerator = [&](std::string BaseName, std::string VarName) {
+    auto IdentifierName = &PP.getIdentifierTable().get(VarName);
 
     // TODO: Fill Fields
     FieldList Fields;
 
-    return std::tuple<std::string, IdentifierInfo*, FieldList>{Name.str(), TestName, Fields};
+    return std::tuple<std::string, IdentifierInfo*, FieldList>{BaseName, IdentifierName, Fields};
   };
 
   printf("\n[PPMC] Parse extension\n");
   ConsumeAnyToken();
+  auto* RD = cast<RecordDecl>(TagDecl);
+  const auto GenName = RD->getDeclName().getAsString();
   while (Tok.isNot(clang::tok::greater)) {
     printf("  Token -> Kind: [%s]", Tok.getName());
     if (Tok.is(clang::tok::identifier)) {
-      auto Name = Tok.getIdentifierInfo()->getName().str();
-      printf(", Name:[%s]", Name.c_str());
-      auto D = DeclGenerator(Tok.getIdentifierInfo()->getName());
+      const auto TokName = Tok.getIdentifierInfo()->getName().str();
+      auto Name = GetVariantName(*this,
+                                 GetMangledName(GenName, TokName),
+                                 NextToken());// Tok.getIdentifierInfo()->getName().str();
+      printf(", Name:[%s]", TokName.c_str());
+      auto D = DeclGenerator(TokName, Name);
       Result.push_back(D);
     }
     printf("\n");
@@ -4642,6 +4675,7 @@ void Parser::ParseStructUnionBody(SourceLocation RecordLoc,
       auto VariantName = std::get<0>(SpecializationTuple);
       auto VariantNameIdentifier = &PP.getIdentifierTable().get(VariantName);
       auto TestName = std::get<1>(SpecializationTuple);
+      printf("[] Test name: %s, Variant Name: %s\n", TestName->getNameStart(), VariantName.c_str());
       ParsingDeclSpec PDS(*this);
       auto VariantDecl = Actions.ActOnTag(getCurScope(), clang::TST_struct, clang::Sema::TUK_Reference,
         TestLocation, TestSS, VariantNameIdentifier, TestLocation, TestAttrs, clang::AS_none, TestLocation,

clang/test/CodeGen/pp-generalization.c

@@ -74,6 +74,14 @@ int test_vars() {
     return get_spec_field1(gb1) + get_spec_field2(gb2);
 }
 
-// struct Base_gen1 { struct Generalization<Base1> b; };
-// struct Base_gen2 { struct Generalization<Base2> b; };
-// struct Generalization_extended { double additional_field; } < Generalization<Base1>, Generalization<Base2> >;
+struct Base_gen1 { struct Generalization<Base1> b; };
+struct Base_gen2 { struct Generalization<Base2> b; };
+// struct Generalization_nested { double additional_field; } < Generalization<Base1>, Generalization<Base2> >;
+struct Generalization_extended { double other_field; } < Base_gen1, Base_gen2 >;
+
+int test_nested_vars() {
+//     struct Generalization_nested<Generalization<Base1>> gn1;
+//     gn1<><i> = 4;
+    struct Generalization_extended<Base_gen1> ge1;
+    // ge1<b><i> = 5;
+}