[IRGen][WMO] type descriptors generated for an imported Clang types are always known local declarations

This fixes a LNK4217 linker warning when building code on Windows

Author: hyp

include/swift/IRGen/Linking.h

@@ -1597,6 +1597,9 @@ class LinkEntity {
            getKind() == Kind::DispatchThunkAllocator ||
            getKind() == Kind::DispatchThunkDerivative;
   }
+  bool isNominalTypeDescriptor() const {
+    return getKind() == Kind::NominalTypeDescriptor;
+  }
 
   /// Determine whether this entity will be weak-imported.
   bool isWeakImported(ModuleDecl *module) const;

lib/IRGen/GenDecl.cpp

@@ -2412,6 +2412,21 @@ LinkInfo LinkInfo::get(const UniversalLinkageInfo &linkInfo,
       isKnownLocal = MD == swiftModule || MD->isStaticLibrary();
   }
 
+  if (!isKnownLocal && !isDefinition) {
+    if (auto *entityDC = entity.getDeclContextForEmission()) {
+      bool isClangImportedEntity =
+          isa<ClangModuleUnit>(entityDC->getModuleScopeContext());
+      // Nominal type descriptor for a type imported from a Clang module
+      // is always a local declaration as it's generated on demand. When WMO is
+      // off, it's emitted into the current file's object file. When WMO is on,
+      // it's emitted into one of the object files in the current module, and
+      // thus it's never imported from outside of the module.
+      if (isClangImportedEntity && entity.isNominalTypeDescriptor()) {
+        isKnownLocal = true;
+      }
+    }
+  }
+
   bool weakImported = entity.isWeakImported(swiftModule);
   result.IRL = getIRLinkage(result.Name, linkInfo,
                             entity.getLinkage(isDefinition), isDefinition,

test/IRGen/imported_clang_type_metadata_is_local.swift

@@ -0,0 +1,53 @@
+// RUN: %empty-directory(%t)
+// RUN: split-file %s %t
+
+// RUN: %target-swift-frontend  -c -num-threads 1 -emit-ir -wmo -O  %t/useA.swift %t/useB.swift -I %t/Inputs -o %t/useA.swift.ir -o %t/useB.swift.ir 
+// RUN: cat %t/useB.swift.ir | %FileCheck %s
+
+//--- Inputs/module.modulemap
+module ClangModule {
+    header "header.h"
+}
+
+//--- Inputs/header.h
+
+struct ImportedClangType {
+  int x;
+};
+
+//--- useA.swift
+
+import ClangModule
+
+func testA<T>(_ x: T) {
+  print(x)
+}
+
+public func testARun() {
+  testA(ImportedClangType(x: 0))
+}
+
+public struct TestUseFieldA {
+  let x: ImportedClangType = ImportedClangType()
+}
+
+//--- useB.swift
+
+import ClangModule
+
+func testB<T>(_ x: T) {
+  print(x)
+}
+
+public func testBRun() {
+  testB(ImportedClangType(x: 0))
+}
+
+public struct TestUseFieldB {
+  let x: ImportedClangType = ImportedClangType()
+}
+
+// The type metadata emitted for TU B, refers to the metadata from TU A,
+// but it doesn't need to dllimport it accross the module boundary, as it's
+// emitted in the same module.
+// CHECK: @"$sSo17ImportedClangTypeVMn" = external global %swift.type_descriptor