[clang][extract-api] Suppprt for the module name property in SymbolGraph

[dang]

Summary

Adds --product-name= flag to the clang driver. This gets forwarded to
cc1 only when we are performing a ExtractAPI Action. This is used to
populate the name field of the module object in the generated SymbolGraph.

Depends on D121936

[zixuw]

LGTM. Need to rebase. Do you think ProductName should be a general property of APISerializer or something specific to the SymbolGraphSerializer?

[dang]

In D122141#3400578, @zixuw wrote:

LGTM. Need to rebase. Do you think ProductName should be a general property of APISerializer or something specific to the SymbolGraphSerializer?

Good question! I think I am going to make it a general property of the APISerializer as it isn't a symbol graph specific concept IMO.

[dang]

Rebasing on top of latest main which includes https://reviews.llvm.org/rG89f6b26f1beb2c1344f5cfeb34e405128544c76b

[dang]

Missed some stuff in the previous rebase.

[dang]

Accidentally re-added some of the old files in SymbolGraph/ during the rebase

clang/include/clang/Driver/Options.td

def emit_merged_ifs : Flag<["-"], "emit-merged-ifs">,
   Flags<[CC1Option]>, Group<Action_Group>,
   HelpText<"Generate Interface Stub Files, emit merged text not binary.">;
 def end_no_unused_arguments : Flag<["--"], "end-no-unused-arguments">, Flags<[CoreOption]>,
   HelpText<"Start emitting warnings for unused driver arguments">;
 def interface_stub_version_EQ : JoinedOrSeparate<["-"], "interface-stub-version=">, Flags<[CC1Option]>;
 def exported__symbols__list : Separate<["-"], "exported_symbols_list">;
 def extract_api : Flag<["-"], "extract-api">, Flags<[CC1Option]>, Group<Action_Group>,
   HelpText<"Extract API information">;
+def product_name_EQ: Joined<["--"], "product-name=">, Flags<[CC1Option]>,
+  MarshallingInfoString<FrontendOpts<"ProductName">>;
 def e : JoinedOrSeparate<["-"], "e">, Flags<[LinkerInput]>, Group<Link_Group>;
 def fmax_tokens_EQ : Joined<["-"], "fmax-tokens=">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Max total number of preprocessed tokens for -Wmax-tokens.">,
   MarshallingInfoInt<LangOpts<"MaxTokens">>;
 def fPIC : Flag<["-"], "fPIC">, Group<f_Group>;
 def fno_PIC : Flag<["-"], "fno-PIC">, Group<f_Group>;
 def fPIE : Flag<["-"], "fPIE">, Group<f_Group>;
 def fno_PIE : Flag<["-"], "fno-PIE">, Group<f_Group>;

clang/include/clang/ExtractAPI/Serialization/SerializerBase.h

 /// The base interface of serializers for API information.
 class APISerializer {
 public:
   /// Serialize the API information to \p os.
   virtual void serialize(raw_ostream &os) = 0;
 
 protected:
   const APISet &API;
+
+  /// The product name of API.
+  ///
+  /// Note: This should be used for populating metadata about the API.
+  StringRef ProductName;
+
   APISerializerOption Options;
 
 public:
   APISerializer() = delete;
   APISerializer(const APISerializer &) = delete;
   APISerializer(APISerializer &&) = delete;
   APISerializer &operator=(const APISerializer &) = delete;
   APISerializer &operator=(APISerializer &&) = delete;
 
 protected:
-  APISerializer(const APISet &API, APISerializerOption Options = {})
-      : API(API), Options(Options) {}
+  APISerializer(const APISet &API, StringRef ProductName,
+                APISerializerOption Options = {})
+      : API(API), ProductName(ProductName), Options(Options) {}
 
   virtual ~APISerializer() = default;
 };
 
 } // namespace extractapi
 } // namespace clang
 
 #endif // LLVM_CLANG_EXTRACTAPI_SERIALIZATION_SERIALIZERBASE_H

clang/include/clang/ExtractAPI/Serialization/SymbolGraphSerializer.h

private:
   /// \returns \c None if this \p Record should be skipped, or a JSON object
   /// containing common symbol information of \p Record.
   Optional<Object> serializeAPIRecord(const APIRecord &Record) const;
 
   /// Serialize a global record.
   void serializeGlobalRecord(const GlobalRecord &Record);
 
 public:
-  SymbolGraphSerializer(const APISet &API, APISerializerOption Options = {})
-      : APISerializer(API, Options) {}
+  SymbolGraphSerializer(const APISet &API, StringRef ProductName,
+                        APISerializerOption Options = {})
+      : APISerializer(API, ProductName, Options) {}
 };
 
 } // namespace extractapi
 } // namespace clang
 
 #endif // LLVM_CLANG_EXTRACTAPI_SERIALIZATION_SYMBOLGRAPHSERIALIZER_H

clang/include/clang/Frontend/FrontendOptions.h

public:
   ParsedSourceLocation CodeCompletionAt;
 
   /// The frontend action to perform.
   frontend::ActionKind ProgramAction = frontend::ParseSyntaxOnly;
 
   /// The name of the action to run when using a plugin action.
   std::string ActionName;
 
+  // Currently this is only used as part of the `-extract-api` action.
+  /// The name of the product the input files belong too.
+  std::string ProductName;
+
   /// Args to pass to the plugins
   std::map<std::string, std::vector<std::string>> PluginArgs;
 
   /// The list of plugin actions to run in addition to the normal action.
   std::vector<std::string> AddPluginActions;
 
   /// The list of plugins to load.
   std::vector<std::string> Plugins;

clang/lib/Driver/ToolChains/Clang.cpp

if (isa<AnalyzeJobAction>(JA)) {
     else
       CmdArgs.push_back("-emit-pch");
   } else if (isa<VerifyPCHJobAction>(JA)) {
     CmdArgs.push_back("-verify-pch");
   } else if (isa<ExtractAPIJobAction>(JA)) {
     assert(JA.getType() == types::TY_API_INFO &&
            "Extract API actions must generate a API information.");
     CmdArgs.push_back("-extract-api");
+    if (Arg *ProductNameArg = Args.getLastArg(options::OPT_product_name_EQ))
+      ProductNameArg->render(Args, CmdArgs);
   } else {
     assert((isa<CompileJobAction>(JA) || isa<BackendJobAction>(JA)) &&
            "Invalid action for clang tool.");
     if (JA.getType() == types::TY_Nothing) {
       CmdArgs.push_back("-fsyntax-only");
     } else if (JA.getType() == types::TY_LLVM_IR ||
                JA.getType() == types::TY_LTO_IR) {
       CmdArgs.push_back("-emit-llvm");

clang/lib/ExtractAPI/ExtractAPIConsumer.cpp

private:
   }
 
   ASTContext &Context;
   APISet API;
 };
 
 class ExtractAPIConsumer : public ASTConsumer {
 public:
-  ExtractAPIConsumer(ASTContext &Context, std::unique_ptr<raw_pwrite_stream> OS)
-      : Visitor(Context), OS(std::move(OS)) {}
+  ExtractAPIConsumer(ASTContext &Context, StringRef ProductName,
+                     std::unique_ptr<raw_pwrite_stream> OS)
+      : Visitor(Context), ProductName(ProductName), OS(std::move(OS)) {}
 
   void HandleTranslationUnit(ASTContext &Context) override {
     // Use ExtractAPIVisitor to traverse symbol declarations in the context.
     Visitor.TraverseDecl(Context.getTranslationUnitDecl());
 
     // Setup a SymbolGraphSerializer to write out collected API information in
     // the Symbol Graph format.
     // FIXME: Make the kind of APISerializer configurable.
-    SymbolGraphSerializer SGSerializer(Visitor.getAPI());
+    SymbolGraphSerializer SGSerializer(Visitor.getAPI(), ProductName);
     SGSerializer.serialize(*OS);
   }
 
 private:
   ExtractAPIVisitor Visitor;
+  std::string ProductName;
   std::unique_ptr<raw_pwrite_stream> OS;
 };
 
 } // namespace
 
 std::unique_ptr<ASTConsumer>
 ExtractAPIAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
   std::unique_ptr<raw_pwrite_stream> OS = CreateOutputFile(CI, InFile);
   if (!OS)
     return nullptr;
-  return std::make_unique<ExtractAPIConsumer>(CI.getASTContext(),
-                                              std::move(OS));
+  return std::make_unique<ExtractAPIConsumer>(
+      CI.getASTContext(), CI.getInvocation().getFrontendOpts().ProductName,
 }
 
 std::unique_ptr<raw_pwrite_stream>
 ExtractAPIAction::CreateOutputFile(CompilerInstance &CI, StringRef InFile) {
   std::unique_ptr<raw_pwrite_stream> OS =
       CI.createDefaultOutputFile(/*Binary=*/false, InFile, /*Extension=*/"json",
                                  /*RemoveFileOnSignal=*/false);
   if (!OS)
     return nullptr;
   return OS;
 }

clang/lib/ExtractAPI/Serialization/SymbolGraphSerializer.cpp

Object SymbolGraphSerializer::serializeMetadata() const {
   serializeObject(Metadata, "formatVersion",
                   serializeSemanticVersion(FormatVersion));
   Metadata["generator"] = clang::getClangFullVersion();
   return Metadata;
 }
 
 Object SymbolGraphSerializer::serializeModule() const {
   Object Module;
-  // FIXME: We might not be building a module, some Clang-based languages might
-  // not have a "module" concept. Figure out a way to provide a name to
-  // describe the API set.
-  Module["name"] = "";
+  // The user is expected to always pass `--product-name=` on the command line
+  // to populate this field.
+  Module["name"] = ProductName;
   serializeObject(Module, "platform", serializePlatform(API.getTarget()));
   return Module;
 }
 
 bool SymbolGraphSerializer::shouldSkip(const APIRecord &Record) const {
   // Skip unconditionally unavailable symbols
   if (Record.Availability.isUnconditionallyUnavailable())
     return true;

clang/test/ExtractAPI/global_record.c

 // RUN: rm -rf %t
 // RUN: split-file %s %t
 // RUN: sed -e "s@INPUT_DIR@%/t@g" %t/reference.output.json.in >> \
 // RUN: %t/reference.output.json
-// RUN: %clang -extract-api -target arm64-apple-macosx \
+// RUN: %clang -extract-api --product-name=GlobalRecord -target arm64-apple-macosx \
 // RUN: %t/input.h -o %t/output.json | FileCheck -allow-empty %s
 
 // Generator version is not consistent across test runs, normalize it.
 // RUN: sed -e "s@\"generator\": \".*\"@\"generator\": \"?\"@g" \
 // RUN: %t/output.json >> %t/output-normalized.json
 // RUN: diff %t/reference.output.json %t/output-normalized.json
 
 // CHECK-NOT: error:
"metadata": {
     "formatVersion": {
       "major": 0,
       "minor": 5,
       "patch": 3
     },
     "generator": "?"
   },
   "module": {
-    "name": "",
+    "name": "GlobalRecord",
     "platform": {
       "architecture": "arm64",
       "operatingSystem": {
         "minimumVersion": {
           "major": 11,
           "minor": 0,
           "patch": 0
         },