Start using BoundNameAliasType for non-generic typealiases in generic contexts

Currently, when we reference a (non-generic) typealias within a
generic context, we would completely lose type sugar for the
typealias, replacing it with the underlying type. Instead, use
BoundNameAliasType for this purpose, which allows us to maintain all
of the type sugar as well as storing complete substitutions for later
use.

Author: DougGregor

lib/Sema/TypeCheckDecl.cpp

@@ -1322,6 +1322,12 @@ class TypeAccessScopeChecker : private TypeWalker, AccessScopeChecker {
     ValueDecl *VD;
     if (auto *TAD = dyn_cast<NameAliasType>(T.getPointer()))
       VD = TAD->getDecl();
+    else if (auto *BNAD = dyn_cast<BoundNameAliasType>(T.getPointer())) {
+      if (CanonicalizeParentTypes)
+        VD = nullptr;
+      else
+        VD = BNAD->getDecl();
+    }
     else if (auto *NTD = T->getAnyNominal())
       VD = NTD;
     else
@@ -1340,6 +1346,11 @@ class TypeAccessScopeChecker : private TypeWalker, AccessScopeChecker {
       nominalParentTy = genericTy->getParent();
       for (auto genericArg : genericTy->getGenericArgs())
         genericArg.walk(*this);
+    } else if (auto boundNameAliasTy =
+                 dyn_cast<BoundNameAliasType>(T.getPointer())) {
+      // The parent type would have been lost previously, so look right through
+      // this type.
+      Type(boundNameAliasTy->getSinglyDesugaredType()).walk(*this);
     } else {
       return Action::Continue;
     }

lib/Sema/TypeCheckType.cpp

@@ -3179,7 +3179,8 @@ Type TypeChecker::substMemberTypeWithBase(ModuleDecl *module,
     }
   }
 
-  if (auto *aliasDecl = dyn_cast<TypeAliasDecl>(member)) {
+  auto *aliasDecl = dyn_cast<TypeAliasDecl>(member);
+  if (aliasDecl) {
     // FIXME: If this is a protocol typealias and we haven't built the
     // protocol's generic environment yet, do so now, to ensure the
     // typealias's underlying type has fully resolved dependent
@@ -3201,7 +3202,15 @@ Type TypeChecker::substMemberTypeWithBase(ModuleDecl *module,
 
   auto subs = baseTy->getContextSubstitutionMap(
       module, member->getDeclContext());
-  return memberType.subst(subs, SubstFlags::UseErrorType);
+  Type resultType = memberType.subst(subs, SubstFlags::UseErrorType);
+
+  // If we're referring to a typealias within a generic context, build
+  // a sugared alias type.
+  if (aliasDecl && aliasDecl->getGenericSignature()) {
+    resultType = BoundNameAliasType::get(aliasDecl, baseTy, subs, resultType);
+  }
+
+  return resultType;
 }
 
 Type TypeChecker::getSuperClassOf(Type type) {

test/ClangImporter/objc_generics_conformance.swift

@@ -21,7 +21,7 @@ protocol WithAssocOther {
 }
 
 extension GenericClass : WithAssocOther {
-  typealias Other = [T] // expected-error{{'GenericClass.Other' involving Objective-C type parameter cannot be used for associated type 'Other' of protocol 'WithAssocOther'}}
+  typealias Other = [T] // expected-error{{type 'GenericClass<T>.Other' involving Objective-C type parameter 'T' cannot be used for associated type 'Other' of protocol 'WithAssocOther'}}
 }
 
 protocol WithAssocElement {

test/Compatibility/accessibility_typealias.swift

@@ -39,7 +39,7 @@ private func privateFuncWithFileprivateAlias() -> Generic<Int>.Dependent {
   return 3
 }
 
-var y = privateFuncWithFileprivateAlias()
+var y = privateFuncWithFileprivateAlias() // expected-warning{{variable should be declared fileprivate because its type 'Generic<Int>.Dependent' (aka 'Int') uses a fileprivate type}}
 
 
 private typealias FnType = (_ x: Int) -> Void // expected-note * {{type declared here}}

test/decl/typealias/dependent_types.swift

@@ -33,14 +33,14 @@ struct GenericStruct<T> { // expected-note 2{{generic type 'GenericStruct' decla
   func methodTwo() -> MetaAlias {}
 
   func methodOne() -> Alias.BadType {}
-  // expected-error@-1 {{'BadType' is not a member type of 'GenericStruct.Alias'}}
+  // expected-error@-1 {{'BadType' is not a member type of 'GenericStruct<T>.Alias'}}
   func methodTwo() -> MetaAlias.BadType {}
-  // expected-error@-1 {{'BadType' is not a member type of 'GenericStruct.MetaAlias'}}
+  // expected-error@-1 {{'BadType' is not a member type of 'GenericStruct<T>.MetaAlias'}}
 
   var propertyOne: Alias.BadType
-  // expected-error@-1 {{'BadType' is not a member type of 'T'}}
+  // expected-error@-1 {{'BadType' is not a member type of 'GenericStruct<T>.Alias' (aka 'T')}}
   var propertyTwo: MetaAlias.BadType
-  // expected-error@-1 {{'BadType' is not a member type of 'T.Type'}}
+  // expected-error@-1 {{'BadType' is not a member type of 'GenericStruct<T>.MetaAlias' (aka 'T.Type')}}
 }
 
 // This was accepted in Swift 3.0 and sort of worked... but we can't

test/decl/typealias/generic.swift

@@ -417,3 +417,18 @@ takesInt(10)
 
 func failsRequirementCheck(_: Element<Int>) {}
 // expected-error@-1 {{type 'Int' does not conform to protocol 'Sequence'}}
+
+//
+// Sugar in base types of a typealias.
+//
+struct X<T, U> {
+  typealias GY<V> = [V]
+}
+
+typealias GX<T> = X<T, T>
+
+func testSugar(_ gx: GX<Int>, _ gy: GX<Int>.GY<Double>, gz: GX<Int>.GY<Double>.Element) {
+  let i: Int = gx   // expected-error{{cannot convert value of type 'GX<Int>' (aka 'X<Int, Int>') to specified type 'Int'}}
+  let i2: Int = gy  // expected-error{{cannot convert value of type 'GX<Int>.GY<Double>' (aka 'Array<Double>') to specified type 'Int'}}
+  let i3: Int = gz // expected-error{{cannot convert value of type 'GX<Int>.GY<Double>.Element' (aka 'Double') to specified type 'Int'}}
+}

validation-test/compiler_crashers/28812-getgenericparams.swift renamed to validation-test/compiler_crashers_fixed/28812-getgenericparams.swift

@@ -5,8 +5,8 @@
 // See https://swift.org/LICENSE.txt for license information
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 
-// REQUIRES: asserts
-// RUN: not --crash %target-swift-frontend %s -emit-ir
+
+// RUN: not %target-swift-frontend %s -emit-ir
 class a<a{{}
 let d=a
 & a