[IRGen] Use symbolic references to (file)private entities in mangled names.

(file)private entities are always available in the current file, so use
symbolic references to refer to them within mangled names (always). This
also eliminates problems stemming from our inability to demangle names
referring to private entities, because we (intentionally) don't allow
lookup for them.

Should fix rdar://problem/44977236.

Author: DougGregor

lib/IRGen/IRGenMangler.cpp

@@ -101,7 +101,10 @@ IRGenMangler::withSymbolicReferences(IRGenModule &IGM,
       // TODO: We ought to be able to use indirect symbolic references even
       // when the referent may be in another file, once the on-disk
       // ObjectMemoryReader can handle them.
-      if (!IGM.CurSourceFile || IGM.CurSourceFile != type->getParentSourceFile())
+      // Private entities are known to be accessible.
+      if (type->getEffectiveAccess() >= AccessLevel::Internal &&
+          (!IGM.CurSourceFile ||
+           IGM.CurSourceFile != type->getParentSourceFile()))
         return false;
 
       // @objc protocols don't have descriptors.
@@ -114,6 +117,7 @@ IRGenMangler::withSymbolicReferences(IRGenModule &IGM,
       llvm_unreachable("symbolic referent not handled");
     }
   };
+
   SymbolicReferences.clear();
 
   body();

test/IRGen/associated_type_witness.swift

@@ -1,6 +1,10 @@
 // RUN: %target-swift-frontend -assume-parsing-unqualified-ownership-sil -primary-file %s -emit-ir > %t.ll
 // RUN: %FileCheck %s -check-prefix=GLOBAL < %t.ll
 // RUN: %FileCheck %s < %t.ll
+
+// RUN: %target-swift-frontend -assume-parsing-unqualified-ownership-sil -primary-file %s -emit-ir -wmo -num-threads 1 > %t.ll.wmo
+// RUN: %FileCheck %s -check-prefix=GLOBAL < %t.ll.wmo
+// RUN: %FileCheck %s < %t.ll.wmo
 // REQUIRES: CPU=x86_64
 
 protocol P {}
@@ -12,6 +16,16 @@ protocol Assocked {
 
 struct Universal : P, Q {}
 
+
+// CHECK-LABEL: @"symbolic _____ 23associated_type_witness12OuterPrivate{{.*}}V" = linkonce_odr hidden constant
+// CHECK-SAME: @"$s23associated_type_witness12OuterPrivate{{.*}}5InnerE0V9InnermostVMn"
+private struct OuterPrivate {
+  struct InnerPrivate: HasSimpleAssoc {
+    struct Innermost { }
+    typealias Assoc = Innermost
+  }
+}
+
 // CHECK: [[ASSOC_TYPE_NAMES:@.*]] = private constant [29 x i8] c"OneAssoc TwoAssoc ThreeAssoc\00"
 // CHECK: @"$s23associated_type_witness18HasThreeAssocTypesMp" =
 // CHECK-SAME: [[ASSOC_TYPE_NAMES]] to i64
@@ -116,7 +130,6 @@ protocol HasSimpleAssoc {
 }
 protocol DerivedFromSimpleAssoc : HasSimpleAssoc {}
 
-
 //   Generic witness table pattern for GenericComputed : DerivedFromSimpleAssoc.
 // GLOBAL-LABEL: @"$s23associated_type_witness15GenericComputedVyxGAA22DerivedFromSimpleAssocAAWp" = internal constant [2 x i8*]
 // GLOBAL-SAME: @"$s23associated_type_witness15GenericComputedVyxGAA22DerivedFromSimpleAssocAAMc"

test/Runtime/associated_type_demangle_private.swift

@@ -0,0 +1,32 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-build-swift -parse-stdlib %s -module-name main -o %t/a.out
+// RUN: %target-codesign %t/a.out
+// RUN: %target-run %t/a.out
+// REQUIRES: executable_test
+
+import Swift
+import StdlibUnittest
+
+protocol P {
+  associatedtype A
+}
+
+fileprivate struct Foo {
+  fileprivate struct Inner: P {
+    fileprivate struct Innermost { }
+    typealias A = Innermost
+  }
+}
+
+func getP_A<T: P>(_: T.Type) -> Any.Type {
+  return T.A.self
+}
+
+let AssociatedTypeDemangleTests = TestSuite("AssociatedTypeDemangle")
+
+
+AssociatedTypeDemangleTests.test("private types") {
+  expectEqual(Foo.Inner.Innermost.self, getP_A(Foo.Inner.self))
+}
+
+runAllTests()