Merge pull request swiftlang#22356 from slavapestov/more-type-reconstruction-fixes

A couple more type reconstruction fixes

Author: slavapestov

include/swift/Demangling/TypeDecoder.h

@@ -301,7 +301,7 @@ class TypeDecoder {
       if (!decodeMangledTypeDecl(Node, typeDecl, parent, typeAlias))
         return BuiltType();
 
-      if (typeAlias && Node->getKind() == NodeKind::TypeAlias)
+      if (typeAlias)
         return Builder.createTypeAliasType(typeDecl, parent);
 
       return Builder.createNominalType(typeDecl, parent);

lib/AST/ASTDemangler.cpp

@@ -126,6 +126,12 @@ Type ASTBuilder::createTypeAliasType(GenericTypeDecl *decl, Type parent) {
   if (aliasDecl->getGenericParams())
     return Type();
 
+  // Imported types can be renamed to be members of other (non-generic)
+  // types, but the mangling does not have a parent type. Just use the
+  // declared type directly in this case and skip the parent check below.
+  if (aliasDecl->hasClangNode() && !aliasDecl->isGenericContext())
+    return aliasDecl->getDeclaredInterfaceType();
+
   // Validate the parent type.
   if (!validateParentType(aliasDecl, parent))
     return Type();
@@ -307,6 +313,10 @@ Type ASTBuilder::createFunctionType(
                               .withVariadic(flags.isVariadic())
                               .withAutoClosure(flags.isAutoClosure());
 
+    if (auto *fnType = type->getAs<FunctionType>())
+      if (!fnType->isNoEscape())
+        parameterFlags = parameterFlags.withEscaping(true);
+
     funcParams.push_back(AnyFunctionType::Param(type, label, parameterFlags));
   }
 

test/TypeDecoder/objc_classes.swift

@@ -18,17 +18,19 @@ do {
   let x2: NSFastEnumeration = x1
   let x3: OurObjCProtocol = OurObjCClass()
   let x4: NSCache = NSCache<NSNumber, NSString>()
+  let x5: PropertyListSerialization.WriteOptions = 0
 
-  blackHole(x1, x2, x3, x4)
+  blackHole(x1, x2, x3, x4, x5)
 }
 
 do {
   let x1: NSSet.Type = NSSet.self
   let x2: NSFastEnumeration.Type = x1
   let x3: OurObjCProtocol.Type = OurObjCClass.self
   let x4: NSCache.Type = NSCache<NSNumber, NSString>.self
+  let x5: PropertyListSerialization.WriteOptions = 0
 
-  blackHole(x1, x2, x3, x4)
+  blackHole(x1, x2, x3, x4, x5)
 }
 
 do {
@@ -42,17 +44,20 @@ do {
 // DEMANGLE: $sSo17NSFastEnumeration_pD
 // DEMANGLE: $s12objc_classes15OurObjCProtocol_pD
 // DEMANGLE: $sSo7NSCacheCySo8NSNumberCSo8NSStringCGD
+// DEMANGLE: $sSo26NSPropertyListWriteOptionsaD
 
 // CHECK: NSSet
 // CHECK: NSFastEnumeration
 // CHECK: OurObjCProtocol
 // CHECK: NSCache<NSNumber, NSString>
+// CHECK: PropertyListSerialization.WriteOptions
 
 // DEMANGLE: $sSo5NSSetCmD
 // DEMANGLE: $sSo5NSSetCXMTD
 // DEMANGLE: $sSo17NSFastEnumeration_pXpD
 // DEMANGLE: $s12objc_classes15OurObjCProtocol_pXpD
 // DEMANGLE: $sSo7NSCacheCySo8NSNumberCSo8NSStringCGmD
+// DEMANGLE: $sSo26NSPropertyListWriteOptionsamD
 
 // CHECK: NSSet.Type
 // CHECK: @thick NSSet.Type
@@ -62,6 +67,8 @@ do {
 
 // CHECK: NSCache<NSNumber, NSString>.Type
 
+// CHECK: PropertyListSerialization.WriteOptions.Type
+
 // DEMANGLE: $sSo17NSFastEnumeration_pmD
 // DEMANGLE: $s12objc_classes15OurObjCProtocol_pmD
 

test/TypeDecoder/structural_types.swift

@@ -116,6 +116,10 @@ do {
   blackHole(metatype)
 }
 
+do {
+  let escaping: (@escaping () -> ()) -> () = { _ in }
+  blackHole(escaping)
+}
 // DEMANGLE: $syycD
 // DEMANGLE: $sySSzcD
 // DEMANGLE: $sySSncD
@@ -131,6 +135,7 @@ do {
 // DEMANGLE: $sSi_SfSitD
 // DEMANGLE: $sSim_Sf1xSitD
 // DEMANGLE: $sSi1x_SfSim1ytD
+// DEMANGLE: $syyyccD
 
 // CHECK: () -> ()
 // CHECK: (inout String) -> ()
@@ -147,6 +152,7 @@ do {
 // CHECK: (Int, Float, Int)
 // CHECK: (Int.Type, x: Float, Int)
 // CHECK: (x: Int, Float, y: Int.Type)
+// CHECK: (@escaping () -> ()) -> ()
 
 // DEMANGLE: $sSimD
 // DEMANGLE: $syycmD
@@ -164,6 +170,7 @@ do {
 // DEMANGLE: $sSi_SfSitmD
 // DEMANGLE: $sSim_Sf1xSitmD
 // DEMANGLE: $sSi1x_SfSim1ytmD
+// DEMANGLE: $syyyccmD
 
 // CHECK: Int.Type
 // CHECK: ((inout String) -> ()).Type
@@ -180,3 +187,4 @@ do {
 // CHECK: (Int, Float, Int).Type
 // CHECK: (Int.Type, x: Float, Int).Type
 // CHECK: (x: Int, Float, y: Int.Type).Type
+// CHECK: ((@escaping () -> ()) -> ()).Type