Emit mangled names for public symbols into the .swiftinterface

When the frontend option `-abi-comments-in-module-interface` is provided
during interface printing, the printed interface will contain
additional comments that provide the mangled names for public symbols.
This is an experiment in seeing how much information we can
meaningfully extract from a printed Swift interface for the purpose of
bridging with other languages.

Author: DougGregor

include/swift/AST/PrintOptions.h

@@ -520,6 +520,10 @@ struct PrintOptions {
   /// with types sharing a name with a module.
   bool AliasModuleNames = false;
 
+  /// Print some ABI details for public symbols as comments that can be
+  /// parsed by another tool.
+  bool PrintABIComments = false;
+
   /// Name of the modules that have been aliased in AliasModuleNames mode.
   /// Ideally we would use something other than a string to identify a module,
   /// but since one alias can apply to more than one module, strings happen
@@ -707,7 +711,8 @@ struct PrintOptions {
                                               bool useExportedModuleNames,
                                               bool aliasModuleNames,
                                               llvm::SmallSet<StringRef, 4>
-                                                *aliasModuleNamesTargets
+                                                *aliasModuleNamesTargets,
+                                              bool abiComments
                                               );
 
   /// Retrieve the set of options suitable for "Generated Interfaces", which

include/swift/Frontend/ModuleInterfaceSupport.h

@@ -42,6 +42,10 @@ struct ModuleInterfaceOptions {
   /// [TODO: Clang-type-plumbing] This check should go away.
   bool PrintFullConvention = false;
 
+  /// Print some ABI details for public symbols as comments that can be
+  /// parsed by another tool.
+  bool ABIComments = false;
+
   struct InterfaceFlags {
     /// Copy of all the command-line flags passed at .swiftinterface
     /// generation time, re-applied to CompilerInvocation when reading

include/swift/Option/FrontendOptions.td

@@ -1049,6 +1049,9 @@ def disable_alias_module_names_in_module_interface :
   Flag<["-"], "disable-alias-module-names-in-module-interface">,
   HelpText<"When emitting a module interface, disable disambiguating modules "
            "using distinct alias names">;
+def abi_comments_in_module_interface :
+  Flag<["-"], "abi-comments-in-module-interface">,
+  HelpText<"When emitting a module interface, emit comments with ABI details">;
 
 def experimental_spi_imports :
   Flag<["-"], "experimental-spi-imports">,

lib/AST/ASTPrinter.cpp

@@ -207,8 +207,8 @@ PrintOptions PrintOptions::printSwiftInterfaceFile(ModuleDecl *ModuleToPrint,
                                                    bool useExportedModuleNames,
                                                    bool aliasModuleNames,
                                                    llvm::SmallSet<StringRef, 4>
-                                                     *aliasModuleNamesTargets
-                                                   ) {
+                                                     *aliasModuleNamesTargets,
+                                                   bool abiComments) {
   PrintOptions result;
   result.IsForSwiftInterface = true;
   result.PrintLongAttrsOnSeparateLines = true;
@@ -230,6 +230,7 @@ PrintOptions PrintOptions::printSwiftInterfaceFile(ModuleDecl *ModuleToPrint,
   result.PreferTypeRepr = preferTypeRepr;
   result.AliasModuleNames = aliasModuleNames;
   result.AliasModuleNamesTargets = aliasModuleNamesTargets;
+  result.PrintABIComments = abiComments;
   if (printFullConvention)
     result.PrintFunctionRepresentationAttrs =
       PrintOptions::FunctionRepresentationMode::Full;
@@ -770,19 +771,28 @@ class PrintAST : public ASTVisitor<PrintAST> {
     printRawComment(RC);
   }
 
+  /// If we should print a mangled name for this declaration, return that
+  /// mangled name.
+  std::optional<std::string> mangledNameToPrint(const Decl *D);
+
   void printDocumentationComment(const Decl *D) {
-    if (!Options.PrintDocumentationComments)
-      return;
+    if (Options.PrintDocumentationComments) {
+      // Try to print a comment from Clang.
+      auto MaybeClangNode = D->getClangNode();
+      if (MaybeClangNode) {
+        if (auto *CD = MaybeClangNode.getAsDecl())
+          printClangDocumentationComment(CD);
+        return;
+      }
 
-    // Try to print a comment from Clang.
-    auto MaybeClangNode = D->getClangNode();
-    if (MaybeClangNode) {
-      if (auto *CD = MaybeClangNode.getAsDecl())
-        printClangDocumentationComment(CD);
-      return;
+      printSwiftDocumentationComment(D);
     }
 
-    printSwiftDocumentationComment(D);
+    if (auto mangledName = mangledNameToPrint(D)) {
+      indent();
+      Printer << "// MANGLED NAME: " << *mangledName;
+      Printer.printNewline();
+    }
   }
 
   void printStaticKeyword(StaticSpellingKind StaticSpelling) {
@@ -3061,6 +3071,60 @@ void PrintAST::printExtension(ExtensionDecl *decl) {
   }
 }
 
+std::optional<std::string> PrintAST::mangledNameToPrint(const Decl *D) {
+  using ASTMangler = Mangle::ASTMangler;
+
+  if (!Options.PrintABIComments)
+    return std::nullopt;
+
+  auto valueDecl = dyn_cast<ValueDecl>(D);
+  if (!valueDecl)
+    return std::nullopt;
+
+  // Anything with an access level less than "package" isn't meant to be
+  // referenced from source code outside the module.
+  if (valueDecl->getEffectiveAccess() < AccessLevel::Package)
+    return std::nullopt;
+
+  // For functions, mangle the entity directly.
+  if (auto func = dyn_cast<FuncDecl>(D)) {
+    ASTMangler mangler;
+    return mangler.mangleEntity(func);
+  }
+
+  // For initializers, mangle the allocating initializer.
+  if (auto init = dyn_cast<ConstructorDecl>(D)) {
+    ASTMangler mangler;
+    return mangler.mangleConstructorEntity(init, /*isAllocating=*/true);
+  }
+
+  // For global and static variables, mangle the entity directly.
+  if (auto var = dyn_cast<VarDecl>(D)) {
+    if (!var->isInstanceMember()) {
+      ASTMangler mangler;
+      return mangler.mangleEntity(var);
+    }
+  }
+
+  // For subscripts, mangle the entity directly.
+  if (auto subscript = dyn_cast<SubscriptDecl>(D)) {
+    ASTMangler mangler;
+    return mangler.mangleEntity(subscript);
+  }
+
+  // For nominal types, mangle the type metadata accessor.
+  if (auto nominal = dyn_cast<NominalTypeDecl>(D)) {
+    if (!isa<ProtocolDecl>(nominal) && !nominal->getGenericSignature()) {
+      ASTMangler mangler;
+      std::string name = mangler.mangleNominalType(nominal);
+      name += "Ma";
+      return name;
+    }
+  }
+
+  return std::nullopt;
+}
+
 static void suppressingFeatureIsolatedAny(PrintOptions &options,
                                           llvm::function_ref<void()> action) {
   llvm::SaveAndRestore<bool> scope(options.SuppressIsolatedAny, true);

lib/Frontend/CompilerInvocation.cpp

@@ -525,6 +525,7 @@ static void ParseModuleInterfaceArgs(ModuleInterfaceOptions &Opts,
     Args.hasArg(OPT_debug_emit_invalid_swiftinterface_syntax);
   Opts.PrintMissingImports =
     !Args.hasArg(OPT_disable_print_missing_imports_in_module_interface);
+  Opts.ABIComments = Args.hasArg(OPT_abi_comments_in_module_interface);
 
   if (const Arg *A = Args.getLastArg(OPT_library_level)) {
     StringRef contents = A->getValue();

lib/Frontend/ModuleInterfaceSupport.cpp

@@ -914,7 +914,7 @@ bool swift::emitSwiftInterface(raw_ostream &out,
       M, Opts.PreserveTypesAsWritten, Opts.PrintFullConvention,
       Opts.InterfaceContentMode,
       useExportedModuleNames,
-      Opts.AliasModuleNames, &aliasModuleNamesTargets);
+      Opts.AliasModuleNames, &aliasModuleNamesTargets, Opts.ABIComments);
   InheritedProtocolCollector::PerTypeMap inheritedProtocolMap;
 
   SmallVector<Decl *, 16> topLevelDecls;

test/ModuleInterface/abi-comments.swift

@@ -0,0 +1,17 @@
+// RUN: %empty-directory(%t)
+
+// RUN: %target-swift-frontend -typecheck -emit-module-interface-path %t/ABIComments.swiftinterface -module-name ABIComments -abi-comments-in-module-interface %s
+
+// RUN: %FileCheck %s < %t/ABIComments.swiftinterface
+
+// CHECK: // MANGLED NAME: $s11ABIComments11intToStringySSSiF
+// CHECK-NEXT: public func intToString(_ value: Swift.Int) -> Swift.String
+public func intToString(_ value: Int) -> String { "\(value)" }
+
+// CHECK: // MANGLED NAME: $s11ABIComments8MyStructVMa
+// CHECK-NEXT: public struct MyStruct {
+public struct MyStruct {
+  // CHECK: // MANGLED NAME: $s11ABIComments8MyStructV6methodSiyF
+  // CHECK-NEXT: public func method() -> Swift.Int
+  public func method() -> Int { 5 }
+}