Improve ClangImporter failure diagnostics

This patch introduces new diagnostics to the ClangImporter to help
explain why certain C, Objective-C or C++ declarations fail to import
into Swift. This patch includes new diagnostics for the following entities:

- C functions
- C struct fields
- Macros
- Objective-C properties
- Objective-C methods

In particular, notes are attached to indicate when any of the above
entities fail to import as a result of refering an incomplete (only
forward declared) type.

The new diangostics are hidden behind two new flags, -enable-experimental-clang-importer-diagnostics
and -enable-experimental-eager-clang-module-diagnostics. The first flag emits diagnostics lazily,
while the second eagerly imports all declarations visible from loaded Clang modules. The first
flag is intended for day to day swiftc use, the second for module linting or debugging the importer.

Author: Nuri Amari

include/swift/AST/ASTContext.h

@@ -1160,6 +1160,9 @@ class ASTContext final {
   InheritedProtocolConformance *
   getInheritedConformance(Type type, ProtocolConformance *inherited);
 
+  /// Check if \p decl is included in LazyContexts.
+  bool isLazyContext(const DeclContext *decl);
+
   /// Get the lazy data for the given declaration.
   ///
   /// \param lazyLoader If non-null, the lazy loader to use when creating the

include/swift/AST/ClangModuleLoader.h

@@ -182,6 +182,9 @@ class ClangModuleLoader : public ModuleLoader {
   /// Imports a clang decl directly, rather than looking up its name.
   virtual Decl *importDeclDirectly(const clang::NamedDecl *decl) = 0;
 
+  /// Emits any import diagnostics associated with the provided decl.
+  virtual void diagnoseDeclDirectly(const clang::NamedDecl *decl) = 0;
+
   /// Instantiate and import class template using given arguments.
   ///
   /// This method will find the clang::ClassTemplateSpecialization decl if

include/swift/AST/DiagnosticEngine.h

@@ -33,6 +33,10 @@
 #include "llvm/Support/SaveAndRestore.h"
 #include "llvm/Support/VersionTuple.h"
 
+namespace clang {
+class NamedDecl;
+}
+
 namespace swift {
   class Decl;
   class DeclAttribute;
@@ -116,7 +120,8 @@ namespace swift {
     VersionTuple,
     LayoutConstraint,
     ActorIsolation,
-    Diagnostic
+    Diagnostic,
+    ClangDecl
   };
 
   namespace diag {
@@ -149,6 +154,7 @@ namespace swift {
       LayoutConstraint LayoutConstraintVal;
       ActorIsolation ActorIsolationVal;
       DiagnosticInfo *DiagnosticVal;
+      const clang::NamedDecl *ClangDecl;
     };
 
   public:
@@ -251,6 +257,9 @@ namespace swift {
         DiagnosticVal(D) {
     }
 
+    DiagnosticArgument(const clang::NamedDecl *ND)
+        : Kind(DiagnosticArgumentKind::ClangDecl), ClangDecl(ND) {}
+
     /// Initializes a diagnostic argument using the underlying type of the
     /// given enum.
     template<
@@ -356,6 +365,11 @@ namespace swift {
       assert(Kind == DiagnosticArgumentKind::Diagnostic);
       return DiagnosticVal;
     }
+
+    const clang::NamedDecl *getAsClangDecl() const {
+      assert(Kind == DiagnosticArgumentKind::ClangDecl);
+      return ClangDecl;
+    }
   };
 
   /// Describes the current behavior to take with a diagnostic.
@@ -1327,18 +1341,20 @@ namespace swift {
     builder();
   }
 
-/// Temporary on-stack storage and unescaping for encoded diagnostic
-/// messages.
-class EncodedDiagnosticMessage {
-  llvm::SmallString<128> Buf;
+  void printClangDeclName(const clang::NamedDecl *ND, llvm::raw_ostream &os);
 
-public:
-  /// \param S A string with an encoded message
-  EncodedDiagnosticMessage(StringRef S);
+  /// Temporary on-stack storage and unescaping for encoded diagnostic
+  /// messages.
+  class EncodedDiagnosticMessage {
+    llvm::SmallString<128> Buf;
 
-  /// The unescaped message to display to the user.
-  const StringRef Message;
-};
+  public:
+    /// \param S A string with an encoded message
+    EncodedDiagnosticMessage(StringRef S);
+
+    /// The unescaped message to display to the user.
+    const StringRef Message;
+  };
 
 /// Returns a value that can be used to select between accessor kinds in
 /// diagnostics.

include/swift/AST/DiagnosticsClangImporter.def

@@ -100,5 +100,30 @@ WARNING(import_multiple_mainactor_attr,none,
 
 ERROR(module_map_not_found, none, "module map file '%0' not found", (StringRef))
 
+NOTE(macro_not_imported_unsupported_operator, none, "operator not supported in macro arithmetic", ())
+NOTE(macro_not_imported_unsupported_named_operator, none, "operator '%0' not supported in macro arithmetic", (StringRef))
+NOTE(macro_not_imported_invalid_string_literal, none, "invalid string literal", ())
+NOTE(macro_not_imported_invalid_numeric_literal, none, "invalid numeric literal", ())
+NOTE(macro_not_imported_unsupported_literal, none, "only numeric and string macro literals supported", ())
+NOTE(macro_not_imported_nested_cast, none, "non-null nested casts not supported", ())
+
+ERROR(macro_not_imported_function_like, none, "macro '%0' not imported: function like macros not supported", (StringRef))
+ERROR(macro_not_imported_unsupported_structure, none, "macro '%0' not imported: structure not supported", (StringRef))
+ERROR(macro_not_imported, none, "macro '%0' not imported", (StringRef))
+
+NOTE(return_type_not_imported, none, "return type not imported", ())
+NOTE(parameter_type_not_imported, none, "parameter %0 not imported", (const clang::NamedDecl*))
+NOTE(incomplete_interface, none, "interface %0 is incomplete", (const clang::NamedDecl*))
+NOTE(incomplete_protocol, none, "protocol %0 is incomplete", (const clang::NamedDecl*))
+NOTE(unsupported_builtin_type, none, "built-in type '%0' not supported", (StringRef))
+
+WARNING(record_field_not_imported, none, "field %0 not imported", (const clang::NamedDecl*))
+WARNING(invoked_func_not_imported, none, "function %0 not imported", (const clang::NamedDecl*))
+WARNING(record_method_not_imported, none, "method %0 not imported", (const clang::NamedDecl*))
+WARNING(objc_property_not_imported, none, "property %0 not imported", (const clang::NamedDecl*))
+
+NOTE(forward_declared_interface_label, none, "interface %0 forward declared here", (const clang::NamedDecl*))
+NOTE(forward_declared_protocol_label, none, "protocol %0 forward declared here", (const clang::NamedDecl*))
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/AST/LazyResolver.h

@@ -85,6 +85,9 @@ class alignas(void*) LazyMemberLoader {
   loadNamedMembers(const IterableDeclContext *IDC, DeclBaseName N,
                    uint64_t contextData) = 0;
 
+  virtual void diagnoseMissingNamedMember(const IterableDeclContext *IDC,
+                                          DeclName name) = 0;
+
   /// Populates the given vector with all conformances for \p D.
   ///
   /// The implementation should \em not call setConformances on \p D.

include/swift/Basic/LangOptions.h

@@ -320,6 +320,12 @@ namespace swift {
     /// Enable experimental flow-sensitive concurrent captures.
     bool EnableExperimentalFlowSensitiveConcurrentCaptures = false;
 
+    /// Enable experimental ClangImporter diagnostics.
+    bool EnableExperimentalClangImporterDiagnostics = false;
+
+    /// Enable experimental eager Clang module diagnostics.
+    bool EnableExperimentalEagerClangModuleDiagnostics = false;
+
     /// Enable inference of Sendable conformances for public types.
     bool EnableInferPublicSendable = false;
 

include/swift/ClangImporter/ClangImporter.h

@@ -40,6 +40,7 @@ namespace clang {
   class EnumDecl;
   class MacroInfo;
   class Module;
+  class ModuleMacro;
   class NamedDecl;
   class Sema;
   class TargetInfo;
@@ -109,6 +110,11 @@ class DWARFImporterDelegate {
   virtual void anchor();
 };
 
+typedef llvm::PointerUnion<const clang::Decl *, const clang::MacroInfo *,
+                           const clang::ModuleMacro *, const clang::Type *,
+                           const clang::Token *>
+    ImportDiagnosticTarget;
+
 /// Class that imports Clang modules into Swift, mapping directly
 /// from Clang ASTs over to Swift ASTs.
 class ClangImporter final : public ClangModuleLoader {
@@ -509,6 +515,9 @@ class ClangImporter final : public ClangModuleLoader {
 
   /// Imports a clang decl directly, rather than looking up it's name.
   Decl *importDeclDirectly(const clang::NamedDecl *decl) override;
+
+  /// Emits any pending diagnostics associated with the provided decl.
+  void diagnoseDeclDirectly(const clang::NamedDecl *decl) override;
 };
 
 ImportDecl *createImportDecl(ASTContext &Ctx, DeclContext *DC, ClangNode ClangN,

include/swift/Option/FrontendOptions.td

@@ -287,6 +287,14 @@ def enable_experimental_flow_sensitive_concurrent_captures :
   Flag<["-"], "enable-experimental-flow-sensitive-concurrent-captures">,
   HelpText<"Enable flow-sensitive concurrent captures">;
 
+def enable_experimental_clang_importer_diagnostics :
+  Flag<["-"], "enable-experimental-clang-importer-diagnostics">,
+  HelpText<"Enable experimental diagnostics when importing C, C++, and Objective-C libraries">;
+
+def enable_experimental_eager_clang_module_diagnostics :
+  Flag<["-"], "enable-experimental-eager-clang-module-diagnostics">,
+  HelpText<"Enable experimental eager diagnostics reporting on the importability of all referenced C, C++, and Objective-C libraries">;
+
 def enable_resilience : Flag<["-"], "enable-resilience">,
      HelpText<"Deprecated, use -enable-library-evolution instead">;
 }

lib/AST/ASTContext.cpp

@@ -2462,6 +2462,10 @@ ASTContext::getInheritedConformance(Type type, ProtocolConformance *inherited) {
   return result;
 }
 
+bool ASTContext::isLazyContext(const DeclContext *dc) {
+  return getImpl().LazyContexts.count(dc) != 0;
+}
+
 LazyContextData *ASTContext::getOrCreateLazyContextData(
                                                 const DeclContext *dc,
                                                 LazyMemberLoader *lazyLoader) {

lib/AST/DiagnosticEngine.cpp

@@ -16,11 +16,11 @@
 //===----------------------------------------------------------------------===//
 
 #include "swift/AST/DiagnosticEngine.h"
-#include "swift/AST/DiagnosticsCommon.h"
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/ASTPrinter.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/DiagnosticSuppression.h"
+#include "swift/AST/DiagnosticsCommon.h"
 #include "swift/AST/Module.h"
 #include "swift/AST/Pattern.h"
 #include "swift/AST/PrintOptions.h"
@@ -30,6 +30,8 @@
 #include "swift/Config.h"
 #include "swift/Localization/LocalizationFormat.h"
 #include "swift/Parse/Lexer.h" // bad dependency
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/Decl.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/CommandLine.h"
@@ -566,6 +568,11 @@ static bool isMainActor(Type type) {
   return false;
 }
 
+void swift::printClangDeclName(const clang::NamedDecl *ND,
+                               llvm::raw_ostream &os) {
+  ND->getNameForDiagnostic(os, ND->getASTContext().getPrintingPolicy(), false);
+}
+
 /// Format a single diagnostic argument and write it to the given
 /// stream.
 static void formatDiagnosticArgument(StringRef Modifier,
@@ -832,6 +839,13 @@ static void formatDiagnosticArgument(StringRef Modifier,
                                            diagArg->FormatArgs);
     break;
   }
+
+  case DiagnosticArgumentKind::ClangDecl:
+    assert(Modifier.empty() && "Improper modifier for ClangDecl argument");
+    Out << FormatOpts.OpeningQuotationMark;
+    printClangDeclName(Arg.getAsClangDecl(), Out);
+    Out << FormatOpts.ClosingQuotationMark;
+    break;
   }
 }