Merge pull request #20353 from DougGregor/mangle-nongeneric-typealias

Author: swift-ci

lib/AST/ASTMangler.cpp

@@ -677,6 +677,27 @@ static bool isStdlibType(const TypeDecl *decl) {
   return dc->isModuleScopeContext() && dc->getParentModule()->isStdlibModule();
 }
 
+/// Whether to mangle the given type as generic.
+static bool shouldMangleAsGeneric(Type type) {
+  if (!type)
+    return false;
+
+  TypeBase *typePtr = type.getPointer();
+  if (auto typeAlias = dyn_cast<NameAliasType>(typePtr))
+    return !typeAlias->getSubstitutionMap().empty();
+
+  if (auto bound = dyn_cast<BoundGenericType>(typePtr))
+    return true;
+
+  if (auto nominal = dyn_cast<NominalType>(typePtr))
+    return shouldMangleAsGeneric(nominal->getParent());
+
+  if (auto unbound = dyn_cast<UnboundGenericType>(typePtr))
+    return shouldMangleAsGeneric(unbound->getParent());
+
+  return false;
+}
+
 /// Mangle a type into the buffer.
 ///
 void ASTMangler::appendType(Type type) {
@@ -845,11 +866,12 @@ void ASTMangler::appendType(Type type) {
     case TypeKind::BoundGenericClass:
     case TypeKind::BoundGenericEnum:
     case TypeKind::BoundGenericStruct: {
-      // We can't use getAnyNominal here because this can be TypeAliasDecl only
-      // in case of UnboundGenericType. Such mangling happens in, for instance,
-      // SourceKit 'cursorinfo' request.
-      auto *Decl = type->getAnyGeneric();
-      if (type->isSpecialized()) {
+      GenericTypeDecl *Decl;
+      if (auto typeAlias = dyn_cast<NameAliasType>(type.getPointer()))
+        Decl = typeAlias->getDecl();
+      else
+        Decl = type->getAnyGeneric();
+      if (shouldMangleAsGeneric(type)) {
         // Try to mangle the entire name as a substitution.
         if (tryMangleSubstitution(tybase))
           return;
@@ -869,7 +891,7 @@ void ASTMangler::appendType(Type type) {
         addSubstitution(type.getPointer());
         return;
       }
-      appendAnyGenericType(Decl);
+      appendAnyGenericType(type->getAnyGeneric());
       return;
     }
 
@@ -1155,14 +1177,23 @@ static bool containsRetroactiveConformance(
 }
 
 void ASTMangler::appendRetroactiveConformances(Type type) {
-  auto nominal = type->getAnyNominal();
-  if (!nominal) return;
+  // Dig out the substitution map to use.
+  SubstitutionMap subMap;
+  ModuleDecl *module;
+  if (auto typeAlias = dyn_cast<NameAliasType>(type.getPointer())) {
+    module = Mod ? Mod : typeAlias->getDecl()->getModuleContext();
+    subMap = typeAlias->getSubstitutionMap();
+  } else {
+    if (type->hasUnboundGenericType())
+      return;
 
-  auto genericSig = nominal->getGenericSignatureOfContext();
-  if (!genericSig) return;
+    auto nominal = type->getAnyNominal();
+    if (!nominal) return;
+
+    module = Mod ? Mod : nominal->getModuleContext();
+    subMap = type->getContextSubstitutionMap(module, nominal);
+  }
 
-  auto module = Mod ? Mod : nominal->getModuleContext();
-  auto subMap = type->getContextSubstitutionMap(module, nominal);
   if (subMap.empty()) return;
 
   unsigned numProtocolRequirements = 0;

test/DebugInfo/typealias.swift

@@ -12,6 +12,14 @@ class DWARF {
   fileprivate static func usePrivateType() -> PrivateType { return () }
 }
 
+struct Generic<T> {
+  enum Inner {
+    case value
+  }
+}
+
+typealias Specific = Generic<Int>
+
 func main () {
   // CHECK-DAG: !DILocalVariable(name: "a",{{.*}} type: ![[DIEOFFSET]]
   let a : DWARF.DIEOffset = 123
@@ -23,6 +31,11 @@ func main () {
   // CHECK-DAG: !DILocalVariable(name: "c",{{.*}} type: ![[PRIVATETYPE]]
   let c = DWARF.usePrivateType()
   markUsed(c);
+
+  // CHECK-DAG: !DILocalVariable(name: "d", {{.*}} type: [[NONGENERIC_TYPE:![0-9]+]])
+  // CHECK: [[NONGENERIC_TYPE]] = !DICompositeType(tag: DW_TAG_structure_type{{.*}} identifier: "$s9typealias7GenericV5InnerOD"
+  let d: Specific.Inner = .value
+  markUsed(d)
 }
 
 main();

validation-test/compiler_crashers_2_fixed/0181-sr8930.swift

@@ -0,0 +1,46 @@
+// RUN: %target-swift-frontend -emit-ir -g -o - %s 
+
+// REQUIRES: objc_interop
+
+import Foundation
+public final class Foo: NSObject, Collection {
+  public var storage = [String: Any]()
+  
+  public typealias DictionaryType = [String: Any]
+  public typealias IndexDistance = Int
+  public typealias Indices = DictionaryType.Indices
+  public typealias Iterator = DictionaryType.Iterator
+  public typealias SubSequence = DictionaryType.SubSequence
+  public typealias Index = DictionaryType.Index
+  
+  public var startIndex: Index { return storage.startIndex }
+  public var endIndex: DictionaryType.Index { return storage.endIndex }
+  public subscript(position: Index) -> Iterator.Element {
+    return storage[position]
+  }
+  
+  public subscript(bounds: Range<Index>) -> SubSequence {
+    return storage[bounds]
+  }
+  
+  public var indices: Indices { return storage.indices }
+  
+  public subscript(key: String) -> Any? {
+    get { return storage[key] }
+    set { storage[key] = newValue }
+  }
+  
+  public func index(after i: Index) -> Index { return storage.index(after: i) }
+  
+  public func makeIterator() -> DictionaryIterator<String, Any> {
+    return storage.makeIterator()
+  }
+  
+  public override func value(forKey key: String) -> Any? {
+    return storage[key]
+  }
+
+  public override func value(forUndefinedKey key: String) -> Any? {
+    return storage[key]
+  }
+}