Attach Lazy ClangImporter Diagnostics as Notes

Clang importer diagnostics that are produced as a result of a reference
in Swift code are attached to as notes to the Sema produced diagnostic
that indicates the declaration is unavailable.

Ex: Notes about why a C function import failed are attached to
the error explaining that the symbol could not be found in scope.

Author: NuriAmari

include/swift/AST/ASTContext.h

@@ -1217,9 +1217,6 @@ 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,8 +182,14 @@ 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;
+  /// Emits diagnostics for any declarations named name
+  /// whose direct declaration context is a TU.
+  virtual void diagnoseTopLevelValue(const DeclName &name) = 0;
+
+  /// Emit diagnostics for declarations named name that are members
+  /// of the provided baseType.
+  virtual void diagnoseMemberValue(const DeclName &name,
+                                   const Type &baseType) = 0;
 
   /// Instantiate and import class template using given arguments.
   ///

include/swift/AST/DiagnosticsClangImporter.def

@@ -107,20 +107,20 @@ 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(macro_not_imported_function_like, none, "macro '%0' not imported: function like macros not supported", (StringRef))
+NOTE(macro_not_imported_unsupported_structure, none, "macro '%0' not imported: structure not supported", (StringRef))
+NOTE(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(record_field_not_imported, none, "field %0 not imported", (const clang::NamedDecl*))
+NOTE(invoked_func_not_imported, none, "function %0 not imported", (const clang::NamedDecl*))
+NOTE(record_method_not_imported, none, "method %0 not imported", (const clang::NamedDecl*))
+NOTE(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*))

include/swift/AST/LazyResolver.h

@@ -85,9 +85,6 @@ 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/AST/NameLookup.h

@@ -491,6 +491,9 @@ void lookupVisibleMemberDecls(VisibleDeclConsumer &Consumer,
 
 namespace namelookup {
 
+void extractDirectlyReferencedNominalTypes(
+    Type type, SmallVectorImpl<NominalTypeDecl *> &decls);
+
 /// Once name lookup has gathered a set of results, perform any necessary
 /// steps to prune the result set before returning it to the caller.
 void pruneLookupResultSet(const DeclContext *dc, NLOptions options,

include/swift/ClangImporter/ClangImporter.h

@@ -517,8 +517,13 @@ 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;
+  /// Emits diagnostics for any declarations named name
+  /// whose direct declaration context is a TU.
+  void diagnoseTopLevelValue(const DeclName &name) override;
+
+  /// Emit diagnostics for declarations named name that are members
+  /// of the provided baseType.
+  void diagnoseMemberValue(const DeclName &name, const Type &baseType) override;
 };
 
 ImportDecl *createImportDecl(ASTContext &Ctx, DeclContext *DC, ClangNode ClangN,

lib/AST/ASTContext.cpp

@@ -2503,10 +2503,6 @@ 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/NameLookup.cpp

@@ -1475,16 +1475,6 @@ DirectLookupRequest::evaluate(Evaluator &evaluator,
   // Look for a declaration with this name.
   auto known = Table.find(name);
   if (known == Table.end()) {
-    // Diagnose the missing member if:
-    // - The flag enabling ClangImporter diagnostics is passed.
-    // - The containing decl is a ClangDecl.
-    // - The containing decl (and DeclContext) is lazy.
-    if (ctx.LangOpts.EnableExperimentalClangImporterDiagnostics &&
-        ctx.isLazyContext(decl) && decl->getDecl()->getClangDecl()) {
-      auto ci =
-          ctx.getOrCreateLazyIterableContextData(decl, /*lazyLoader=*/nullptr);
-      ci->loader->diagnoseMissingNamedMember(decl, name);
-    }
     return TinyPtrVector<ValueDecl *>();
   }
 
@@ -1601,8 +1591,8 @@ void namelookup::pruneLookupResultSet(const DeclContext *dc, NLOptions options,
 
 /// Inspect the given type to determine which nominal type declarations it
 /// directly references, to facilitate name lookup into those types.
-static void extractDirectlyReferencedNominalTypes(
-              Type type, SmallVectorImpl<NominalTypeDecl *> &decls) {
+void namelookup::extractDirectlyReferencedNominalTypes(
+    Type type, SmallVectorImpl<NominalTypeDecl *> &decls) {
   if (auto nominal = type->getAnyNominal()) {
     decls.push_back(nominal);
     return;
@@ -1674,7 +1664,8 @@ bool DeclContext::lookupQualified(Type type,
 
   // Figure out which nominal types we will look into.
   SmallVector<NominalTypeDecl *, 4> nominalTypesToLookInto;
-  extractDirectlyReferencedNominalTypes(type, nominalTypesToLookInto);
+  namelookup::extractDirectlyReferencedNominalTypes(type,
+                                                    nominalTypesToLookInto);
 
   return lookupQualified(nominalTypesToLookInto, member, options, decls);
 }

lib/ClangImporter/ClangImporter.cpp

@@ -3275,11 +3275,6 @@ void ClangModuleUnit::lookupValue(DeclName name, NLKind lookupKind,
   if (auto lookupTable = owner.findLookupTable(clangModule)) {
     // Search it.
     owner.lookupValue(*lookupTable, name, *consumer);
-    if (getASTContext().LangOpts.EnableExperimentalClangImporterDiagnostics) {
-      if (results.empty()) {
-        owner.diagnoseValue(*lookupTable, name);
-      }
-    }
   }
 }
 
@@ -4127,7 +4122,7 @@ void ClangImporter::Implementation::lookupVisibleDecls(
     DeclBaseName name = baseName.toDeclBaseName(SwiftContext);
     if (!lookupValue(table, name, consumer) &&
         SwiftContext.LangOpts.EnableExperimentalEagerClangModuleDiagnostics) {
-      diagnoseValue(table, name);
+      diagnoseTopLevelValue(name);
     }
   }
 }
@@ -4183,30 +4178,42 @@ void ClangImporter::Implementation::lookupAllObjCMembers(
   }
 }
 
-void ClangImporter::Implementation::diagnoseValue(SwiftLookupTable &table,
-                                                  DeclName name) {
-  auto &clangCtx = getClangASTContext();
-  auto clangTU = clangCtx.getTranslationUnitDecl();
-
-  if (name.isOperator()) {
-    for (auto entry : table.lookupMemberOperators(name.getBaseName())) {
-      diagnoseTargetDirectly(entry);
+void ClangImporter::Implementation::diagnoseTopLevelValue(
+    const DeclName &name) {
+  forEachLookupTable([&](SwiftLookupTable &table) -> bool {
+    for (const auto &entry :
+         table.lookup(name.getBaseName(),
+                      EffectiveClangContext(
+                          getClangASTContext().getTranslationUnitDecl()))) {
+      diagnoseTargetDirectly(importDiagnosticTargetFromLookupTableEntry(entry));
     }
-  }
+    return false;
+  });
+}
 
-  for (auto entry : table.lookup(name.getBaseName(), clangTU)) {
-    diagnoseTargetDirectly(importDiagnosticTargetFromLookupTableEntry(entry));
-  }
+void ClangImporter::Implementation::diagnoseMemberValue(
+    const DeclName &name, const clang::DeclContext *container) {
+  forEachLookupTable([&](SwiftLookupTable &table) -> bool {
+    for (const auto &entry :
+         table.lookup(name.getBaseName(), EffectiveClangContext(container))) {
+      if (clang::NamedDecl *nd = entry.get<clang::NamedDecl *>()) {
+        // We are only interested in members of a particular context,
+        // skip other contexts.
+        if (nd->getDeclContext() != container)
+          continue;
+
+        diagnoseTargetDirectly(
+            importDiagnosticTargetFromLookupTableEntry(entry));
+      }
+      // If the entry is not a NamedDecl, it is a form of macro, which cannot be
+      // a member value.
+    }
+    return false;
+  });
 }
 
 void ClangImporter::Implementation::diagnoseTargetDirectly(
     ImportDiagnosticTarget target) {
-  if (!(SwiftContext.LangOpts.EnableExperimentalClangImporterDiagnostics ||
-        SwiftContext.LangOpts.EnableExperimentalEagerClangModuleDiagnostics) ||
-      DiagnosedValues.count(target))
-    return;
-
-  DiagnosedValues.insert(target);
   if (const clang::Decl *decl = target.dyn_cast<const clang::Decl *>()) {
     Walker.TraverseDecl(const_cast<clang::Decl *>(decl));
   } else if (const clang::MacroInfo *macro =
@@ -4363,8 +4370,6 @@ TinyPtrVector<ValueDecl *> ClangRecordMemberLookup::evaluate(
         recordDecl->getClangDecl()) {
       if (auto import = ctx.getClangModuleLoader()->importDeclDirectly(named))
         result.push_back(cast<ValueDecl>(import));
-      else if (ctx.LangOpts.EnableExperimentalClangImporterDiagnostics)
-        ctx.getClangModuleLoader()->diagnoseDeclDirectly(named);
     }
   }
 
@@ -4497,22 +4502,6 @@ ClangImporter::Implementation::loadNamedMembers(
   return Members;
 }
 
-void ClangImporter::Implementation::diagnoseMissingNamedMember(
-    const IterableDeclContext *IDC, DeclName name) {
-  Optional<clang::Module *> containingModule =
-      getClangSubmoduleForDecl(IDC->getDecl()->getClangDecl());
-  assert(containingModule &&
-         "Members should never be loaded from a forward-declared decl");
-  auto allResults = evaluateOrDefault(
-      SwiftContext.evaluator,
-      ClangDirectLookupRequest({const_cast<Decl *>(IDC->getDecl()),
-                                IDC->getDecl()->getClangDecl(), name}),
-      {});
-  for (auto entry : allResults) {
-    diagnoseTargetDirectly(importDiagnosticTargetFromLookupTableEntry(entry));
-  }
-}
-
 EffectiveClangContext ClangImporter::Implementation::getEffectiveClangContext(
     const NominalTypeDecl *nominal) {
   // If we have a Clang declaration, look at it to determine the
@@ -4747,6 +4736,23 @@ Decl *ClangImporter::importDeclDirectly(const clang::NamedDecl *decl) {
   return Impl.importDecl(decl, Impl.CurrentVersion);
 }
 
-void ClangImporter::diagnoseDeclDirectly(const clang::NamedDecl *decl) {
-  Impl.diagnoseTargetDirectly(decl);
+void ClangImporter::diagnoseTopLevelValue(const DeclName &name) {
+  Impl.diagnoseTopLevelValue(name);
+}
+
+void ClangImporter::diagnoseMemberValue(const DeclName &name,
+                                        const Type &baseType) {
+  if (!baseType->getAnyNominal())
+    return;
+
+  SmallVector<NominalTypeDecl *, 4> nominalTypesToLookInto;
+  namelookup::extractDirectlyReferencedNominalTypes(baseType,
+                                                    nominalTypesToLookInto);
+  for (auto containerDecl : nominalTypesToLookInto) {
+    const clang::Decl *clangContainerDecl = containerDecl->getClangDecl();
+    if (clangContainerDecl && isa<clang::DeclContext>(clangContainerDecl)) {
+      Impl.diagnoseMemberValue(name,
+                               cast<clang::DeclContext>(clangContainerDecl));
+    }
+  }
 }

lib/ClangImporter/ImporterImpl.h

@@ -404,11 +404,6 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
   std::unordered_set<ImportDiagnostic, ImportDiagnosticHasher>
       CollectedDiagnostics;
 
-  // ClangNodes for which all import diagnostics have been both collected and
-  // emitted.
-  std::unordered_set<ImportDiagnosticTarget, ImportDiagnosticTargetHasher>
-      DiagnosedValues;
-
   const bool ImportForwardDeclarations;
   const bool DisableSwiftBridgeAttr;
   const bool BridgingHeaderExplicitlyRequested;
@@ -1455,9 +1450,6 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
   loadNamedMembers(const IterableDeclContext *IDC, DeclBaseName N,
                    uint64_t contextData) override;
 
-  virtual void diagnoseMissingNamedMember(const IterableDeclContext *IDC,
-                                          DeclName name) override;
-
 private:
   void
   loadAllMembersOfObjcContainer(Decl *D,
@@ -1600,8 +1592,14 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
   void lookupAllObjCMembers(SwiftLookupTable &table,
                             VisibleDeclConsumer &consumer);
 
-  /// Emit any import diagnostics associated with the given name.
-  void diagnoseValue(SwiftLookupTable &table, DeclName name);
+  /// Emits diagnostics for any declarations named name
+  /// whose direct declaration context is a TU.
+  void diagnoseTopLevelValue(const DeclName &name);
+
+  /// Emit diagnostics for declarations named name that are members
+  /// of the provided container.
+  void diagnoseMemberValue(const DeclName &name,
+                           const clang::DeclContext *container);
 
   /// Emit any import diagnostics associated with the given Clang node.
   void diagnoseTargetDirectly(ImportDiagnosticTarget target);