[llvm][TextAPI] Clean up minor bugs in YAML TextStub

[cishida]

Summary

• Always print out maccatalyst in format
• Traverse symbols via InterfaceFile symbol APIs
• Properly track addition of flags.

[cishida]

Apply to older format

[ributzka]

LGTM

llvm/lib/TextAPI/TextStub.cpp

NormalizedTBD_V4(IO &IO, const InterfaceFile *&File) {
         }
       }
 
       assignTargetsToLibrary(File->allowableClients(), AllowableClients);
       assignTargetsToLibrary(File->reexportedLibraries(), ReexportedLibraries);
 
       auto handleSymbols =
           [](SectionList &CurrentSections,
-             InterfaceFile::const_filtered_symbol_range Symbols,
-             std::function<bool(const Symbol *)> Pred) {
+             InterfaceFile::const_filtered_symbol_range Symbols) {
             std::set<TargetList> TargetSet;
             std::map<const Symbol *, TargetList> SymbolToTargetList;
             for (const auto *Symbol : Symbols) {
-              if (!Pred(Symbol))
-                continue;
               TargetList Targets(Symbol->targets());
               SymbolToTargetList[Symbol] = Targets;
               TargetSet.emplace(std::move(Targets));
             }
             for (const auto &TargetIDs : TargetSet) {
               SymbolSection CurrentSection;
               CurrentSection.Targets.insert(CurrentSection.Targets.begin(),
                                             TargetIDs.begin(), TargetIDs.end());
NormalizedTBD_V4(IO &IO, const InterfaceFile *&File) {
               sort(CurrentSection.ClassEHs);
               sort(CurrentSection.Ivars);
               sort(CurrentSection.WeakSymbols);
               sort(CurrentSection.TlvSymbols);
               CurrentSections.emplace_back(std::move(CurrentSection));
             }
           };
 
-      handleSymbols(Exports, File->exports(), [](const Symbol *Symbol) {
-        return !Symbol->isReexported();
-      });
-      handleSymbols(Reexports, File->exports(), [](const Symbol *Symbol) {
-        return Symbol->isReexported();
-      });
-      handleSymbols(Undefineds, File->undefineds(),
-                    [](const Symbol *Symbol) { return true; });
+      handleSymbols(Exports, File->exports());
+      handleSymbols(Reexports, File->reexports());
+      handleSymbols(Undefineds, File->undefineds());
     }
 
     const InterfaceFile *denormalize(IO &IO) {
       auto Ctx = reinterpret_cast<TextAPIContext *>(IO.getContext());
       assert(Ctx);
 
       auto *File = new InterfaceFile;
       File->setPath(Ctx->Path);
const InterfaceFile *denormalize(IO &IO) {
                                   SymbolFlags Flag = SymbolFlags::None) {
         for (const auto &CurrentSection : CurrentSections) {
           for (auto &sym : CurrentSection.Symbols)
             File->addSymbol(SymbolKind::GlobalSymbol, sym,
                             CurrentSection.Targets, Flag);
 
           for (auto &sym : CurrentSection.Classes)
             File->addSymbol(SymbolKind::ObjectiveCClass, sym,
-                            CurrentSection.Targets);
+                            CurrentSection.Targets, Flag);
 
           for (auto &sym : CurrentSection.ClassEHs)
             File->addSymbol(SymbolKind::ObjectiveCClassEHType, sym,
-                            CurrentSection.Targets);
+                            CurrentSection.Targets, Flag);
 
           for (auto &sym : CurrentSection.Ivars)
             File->addSymbol(SymbolKind::ObjectiveCInstanceVariable, sym,
-                            CurrentSection.Targets);
+                            CurrentSection.Targets, Flag);
 
-          for (auto &sym : CurrentSection.WeakSymbols)
+          for (auto &sym : CurrentSection.WeakSymbols) {
+            SymbolFlags SymFlag = (Flag == SymbolFlags::Undefined)
+                                      ? SymbolFlags::WeakReferenced
+                                      : SymbolFlags::WeakDefined;
             File->addSymbol(SymbolKind::GlobalSymbol, sym,
-                            CurrentSection.Targets, SymbolFlags::WeakDefined);
+                            CurrentSection.Targets, Flag | SymFlag);
+          }
 
           for (auto &sym : CurrentSection.TlvSymbols)
             File->addSymbol(SymbolKind::GlobalSymbol, sym,
                             CurrentSection.Targets,
-                            SymbolFlags::ThreadLocalValue);
+                            Flag | SymbolFlags::ThreadLocalValue);
         }
       };
 
       handleSymbols(Exports);
       handleSymbols(Reexports, SymbolFlags::Rexported);
       handleSymbols(Undefineds, SymbolFlags::Undefined);
 
       return File;

llvm/lib/TextAPI/TextStubCommon.cpp

case PLATFORM_TVOSSIMULATOR:
     [[fallthrough]];
   case PLATFORM_TVOS:
     OS << "tvos";
     break;
   case PLATFORM_BRIDGEOS:
     OS << "bridgeos";
     break;
   case PLATFORM_MACCATALYST:
-    OS << "iosmac";
+    OS << "maccatalyst";
     break;
   case PLATFORM_DRIVERKIT:
     OS << "driverkit";
     break;
   }
 }
 
 StringRef ScalarTraits<PlatformSet>::input(StringRef Scalar, void *IO,
StringRef ScalarTraits<PlatformSet>::input(StringRef Scalar, void *IO,
 
   auto Platform = StringSwitch<PlatformType>(Scalar)
                       .Case("macosx", PLATFORM_MACOS)
                       .Case("ios", PLATFORM_IOS)
                       .Case("watchos", PLATFORM_WATCHOS)
                       .Case("tvos", PLATFORM_TVOS)
                       .Case("bridgeos", PLATFORM_BRIDGEOS)
                       .Case("iosmac", PLATFORM_MACCATALYST)
+                      .Case("maccatalyst", PLATFORM_MACCATALYST)
                       .Case("driverkit", PLATFORM_DRIVERKIT)
                       .Default(PLATFORM_UNKNOWN);
 
   if (Platform == PLATFORM_MACCATALYST)
     if (Ctx && Ctx->FileKind != FileType::TBD_V3)
       return "invalid platform";
 
   if (Platform == PLATFORM_UNKNOWN)

llvm/unittests/TextAPI/TextStubV3Tests.cpp

TEST(TBDv3, Platform_bridgeOS) {
   Error WriteResult = TextAPIWriter::writeToStream(OS, *File);
   EXPECT_TRUE(!WriteResult);
   EXPECT_EQ(stripWhitespace(TBDv3BridgeOS), stripWhitespace(Buffer.c_str()));
 }
 
 TEST(TBDv3, Platform_macCatalyst) {
   static const char TBDv3PlatformiOSmac[] = "--- !tapi-tbd-v3\n"
                                             "archs: [ armv7k ]\n"
-                                            "platform: iosmac\n"
+                                            "platform: maccatalyst\n"
                                             "install-name: Test.dylib\n"
                                             "...\n";
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv3PlatformiOSmac, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto Platform = PLATFORM_MACCATALYST;
   TBDFile File = std::move(Result.get());

llvm/unittests/TextAPI/TextStubV4Tests.cpp

static const char TBDv4File[] =
       "  - targets: [ x86_64-macos, x86_64-ios ]\n"
       "    symbols: [_symAB]\n"
       "reexports:\n"
       "  - targets: [ i386-macos ]\n"
       "    symbols: [_symC]\n"
       "    objc-classes: []\n"
       "    objc-eh-types: []\n"
       "    objc-ivars: []\n"
-      "    weak-symbols: []\n"
+      "    weak-symbols: [weakReexport]\n"
       "    thread-local-symbols: []\n"
       "undefineds:\n"
       "  - targets: [ i386-macos ]\n"
       "    symbols: [ _symD ]\n"
       "    objc-classes: []\n"
       "    objc-eh-types: []\n"
       "    objc-ivars: []\n"
-      "    weak-symbols: []\n"
+      "    weak-symbols: [weakReference]\n"
       "    thread-local-symbols: []\n"
       "...\n";
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv4File, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
TEST(TBDv4, ReadFile) {
   InterfaceFileRef reexport("/System/Library/Frameworks/A.framework/A",
                             {Targets[0]});
   EXPECT_EQ(1U, File->allowableClients().size());
   EXPECT_EQ(client, File->allowableClients().front());
   EXPECT_EQ(1U, File->reexportedLibraries().size());
   EXPECT_EQ(reexport, File->reexportedLibraries().front());
 
   ExportedSymbolSeq Exports, Reexports, Undefineds;
-  ExportedSymbol temp;
   for (const auto *Sym : File->symbols()) {
-    temp = ExportedSymbol{Sym->getKind(), std::string(Sym->getName()),
-                          Sym->isWeakDefined(), Sym->isThreadLocalValue()};
+    ExportedSymbol Temp =
+        ExportedSymbol{Sym->getKind(), std::string(Sym->getName()),
+                       Sym->isWeakDefined() || Sym->isWeakReferenced(),
+                       Sym->isThreadLocalValue()};
+    if (Sym->isUndefined()) {
+      EXPECT_FALSE(Sym->isWeakDefined());
+      Undefineds.emplace_back(std::move(Temp));
+    }
+    // Check that defined symbols cannot be set as weak referenced.
+    else if (Sym->isReexported()) {
       EXPECT_FALSE(Sym->isWeakReferenced());
-    if (Sym->isUndefined())
-      Undefineds.emplace_back(std::move(temp));
-    else
-      Sym->isReexported() ? Reexports.emplace_back(std::move(temp))
-                          : Exports.emplace_back(std::move(temp));
+      Reexports.emplace_back(std::move(Temp));
+    } else {
+      EXPECT_FALSE(Sym->isWeakReferenced());
+      Exports.emplace_back(std::move(Temp));
+    }
   }
   llvm::sort(Exports);
   llvm::sort(Reexports);
   llvm::sort(Undefineds);
 
   static ExportedSymbol ExpectedExportedSymbols[] = {
       {SymbolKind::GlobalSymbol, "_symA", false, false},
       {SymbolKind::GlobalSymbol, "_symAB", false, false},
       {SymbolKind::GlobalSymbol, "_symB", false, false},
   };
 
   static ExportedSymbol ExpectedReexportedSymbols[] = {
       {SymbolKind::GlobalSymbol, "_symC", false, false},
+      {SymbolKind::GlobalSymbol, "weakReexport", true, false},
   };
 
   static ExportedSymbol ExpectedUndefinedSymbols[] = {
       {SymbolKind::GlobalSymbol, "_symD", false, false},
+      {SymbolKind::GlobalSymbol, "weakReference", true, false},
   };
 
   EXPECT_EQ(std::size(ExpectedExportedSymbols), Exports.size());
   EXPECT_EQ(std::size(ExpectedReexportedSymbols), Reexports.size());
   EXPECT_EQ(std::size(ExpectedUndefinedSymbols), Undefineds.size());
   EXPECT_TRUE(std::equal(Exports.begin(), Exports.end(),
                          std::begin(ExpectedExportedSymbols)));
   EXPECT_TRUE(std::equal(Reexports.begin(), Reexports.end(),