[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(IO &IO, const InterfaceFile *&File) {
       std::set<ArchitectureSet> ArchSet;
       for (const auto &Library : File->allowableClients())
         ArchSet.insert(Library.getArchitectures());
 
       for (const auto &Library : File->reexportedLibraries())
         ArchSet.insert(Library.getArchitectures());
 
       std::map<const Symbol *, ArchitectureSet> SymbolToArchSet;
-      for (const auto *Symbol : File->exports()) {
+      for (const auto *Symbol : File->symbols()) {
         auto Architectures = Symbol->getArchitectures();
         SymbolToArchSet[Symbol] = Architectures;
         ArchSet.insert(Architectures);
       }
 
       for (auto Architectures : ArchSet) {
         ExportSection Section;
         Section.Architectures = Architectures;
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)
+          SymbolFlags SymFlag = (Flag == SymbolFlags::Undefined)
+                                    ? SymbolFlags::WeakReferenced
+                                    : SymbolFlags::WeakDefined;
+          for (auto &sym : CurrentSection.WeakSymbols) {
             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/lib/TextAPI/TextStubV5.cpp

 //===- TextStubV5.cpp -----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Implements Text Stub JSON mappings.
 //
 //===----------------------------------------------------------------------===//
 #include "TextStubCommon.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/JSON.h"
+#include <utility>
 
 // clang-format off
 /*
 
 JSON Format specification.
 
 All library level keys, accept target values and are defaulted if not specified. 
 
Err = collectFromArray(
       TBDKey::ObjCIvar, Segment, [&Result, &SectionFlag](StringRef Name) {
         JSONSymbol Sym = {SymbolKind::ObjectiveCInstanceVariable, Name.str(),
                           SectionFlag};
         Result.back().second.emplace_back(Sym);
       });
   if (Err)
     return Err;
 
-  SymbolFlags WeakFlag = SectionFlag | (SectionFlag == SymbolFlags::Undefined
-                                            ? SymbolFlags::WeakReferenced
-                                            : SymbolFlags::WeakDefined);
+  SymbolFlags WeakFlag =
+      SectionFlag |
+      (((SectionFlag & SymbolFlags::Undefined) == SymbolFlags::Undefined)
   Err = collectFromArray(
       TBDKey::Weak, Segment, [&Result, WeakFlag](StringRef Name) {
         JSONSymbol Sym = {SymbolKind::GlobalSymbol, Name.str(), WeakFlag};
         Result.back().second.emplace_back(Sym);
       });
   if (Err)
     return Err;
 
for (auto Val : *Section) {
 
     auto TargetsOrErr = getTargets(Obj);
     if (!TargetsOrErr) {
       MappedTargets = Targets;
       consumeError(TargetsOrErr.takeError());
     } else {
       MappedTargets = *TargetsOrErr;
     }
-    Result.emplace_back(std::make_pair(Targets, std::vector<JSONSymbol>()));
+    Result.emplace_back(
+        std::make_pair(std::move(MappedTargets), std::vector<JSONSymbol>()));
 
     auto *DataSection = Obj->getObject(Keys[TBDKey::Data]);
     auto *TextSection = Obj->getObject(Keys[TBDKey::Text]);
     // There should be at least one valid section.
     if (!DataSection && !TextSection)
       return make_error<JSONStubError>(getParseErrorMsg(Key));
 
     if (DataSection) {

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(),

llvm/unittests/TextAPI/TextStubV5Tests.cpp

]})";
   InterfaceFile NestedFileB;
   NestedFileB.setFileType(FileType::TBD_V5);
   NestedFileB.setInstallName("@rpath/libfoo.dylib");
   NestedFileB.addTarget(AllTargets[0]);
   NestedFileB.setCompatibilityVersion(PackedVersion(1, 0, 0));
   NestedFileB.setCurrentVersion(PackedVersion(1, 0, 0));
   NestedFileB.setTwoLevelNamespace();
   NestedFileB.setApplicationExtensionSafe(true);
-  NestedFileB.addSymbol(SymbolKind::GlobalSymbol, "_varFooBaz", AllTargets,
+  NestedFileB.addSymbol(SymbolKind::GlobalSymbol, "_varFooBaz", {AllTargets[0]},
                         SymbolFlags::Data);
   File.addDocument(std::make_shared<InterfaceFile>(std::move(NestedFileB)));
 
   // Write out file then process it back into IF and compare equality
   // against TBDv5File.
   SmallString<4096> Buffer;
   raw_svector_ostream OS(Buffer);
   Error Result = TextAPIWriter::writeToStream(OS, File, /*Compact=*/true);