Revert "Progress towards nested generic typealiases." apparently broke an LLDB test.

This reverts commit 2896fbb.

Author: lattner

lib/AST/Type.cpp

@@ -1314,9 +1314,7 @@ TypeBase *NameAliasType::getSinglyDesugaredType() {
 
   // The type for a generic TypeAliasDecl is an UnboundGenericType.
   if (TAD->getGenericParams())
-    return UnboundGenericType::get(TAD,
-                           TAD->getDeclContext()->getDeclaredTypeInContext(),
-                                   TAD->getASTContext());
+    return UnboundGenericType::get(TAD, Type(), TAD->getASTContext());
 
   return getDecl()->getUnderlyingType().getPointer();
 }

lib/Sema/TypeCheckDecl.cpp

@@ -3481,7 +3481,8 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
         TAD->getUnderlyingTypeLoc().setInvalidType(TC.Context);
       } else if (TAD->getDeclContext()->isGenericContext()) {
         TAD->setInterfaceType(
-          ArchetypeBuilder::mapTypeOutOfContext(TAD, TAD->getType()));
+          ArchetypeBuilder::mapTypeOutOfContext(TAD->getDeclContext(),
+                                                TAD->getType()));
       }
 
       // We create TypeAliasTypes with invalid underlying types, so we
@@ -6258,9 +6259,6 @@ void TypeChecker::validateDecl(ValueDecl *D, bool resolveTypeParams) {
 
     // Check generic parameters, if needed.
     if (auto gp = typeAlias->getGenericParams()) {
-      gp->setOuterParameters(
-                     typeAlias->getDeclContext()->getGenericParamsOfContext());
-
       // Validate the generic type parameters.
       if (validateGenericTypeSignature(typeAlias)) {
         markInvalidGenericSignature(typeAlias, *this);
@@ -6274,9 +6272,7 @@ void TypeChecker::validateDecl(ValueDecl *D, bool resolveTypeParams) {
         revertGenericParamList(gp);
 
         auto builder = createArchetypeBuilder(typeAlias->getModuleContext());
-        auto *parentSig = typeAlias->getDeclContext()->
-           getGenericSignatureOfContext();
-        checkGenericParamList(&builder, gp, parentSig);
+        checkGenericParamList(&builder, gp, nullptr/*parentSig*/);
         finalizeGenericParamList(builder, gp, typeAlias, *this);
       }
     }

lib/Sema/TypeCheckType.cpp

@@ -455,25 +455,12 @@ Type TypeChecker::applyUnboundGenericArguments(
   // If we're completing a generic TypeAlias, then we map the types provided
   // onto the underlying type.
   if (auto *TAD = dyn_cast<TypeAliasDecl>(unbound->getDecl())) {
-    auto signature = TAD->getGenericSignature();
     assert(TAD->getGenericParams()->getAllArchetypes().size()
              == genericArgs.size() &&
-           signature->getInnermostGenericParams().size() == genericArgs.size()&&
            "argument arity mismatch");
 
     SmallVector<Substitution, 4> subs;
     subs.reserve(genericArgs.size());
-    
-    // If we have any nested archetypes from an outer type, include them
-    // verbatim.
-    auto outerParams = signature->getGenericParams();
-    outerParams = outerParams.drop_back(genericArgs.size());
-    for (auto param : outerParams) {
-      Type type = resolver->resolveGenericTypeParamType(param);
-
-      subs.push_back(Substitution(type, {}));
-    }
-    
     for (auto t : genericArgs)
       subs.push_back(Substitution(t.getType(), {}));
 

test/decl/typealias/typealias.swift

@@ -92,6 +92,8 @@ let _ : D = D<Int, Int, Float>(a: 1, b: 2)
 // expected-error @+1 {{generic parameter 'T3' could not be inferred}}
 let _ : D<Int, Int, Float> = D(a: 1, b: 2)
 
+
+
 let _ : F = { (a : Int) -> Int in a }  // Infer the types of F
 
 // TODO QoI: Cannot infer T1/T2.
@@ -114,21 +116,6 @@ _ = G<Int, String>(a: "foo", b: 42)
 
 
 
-// FIXME: Nested generic typealiases aren't working yet.
-struct GenericStruct<T> {
-  typealias TA<U> = MyType<T, U>
-  
-  func testCapture<S>(s : S, t : T) -> TA<S> {  // expected-error {{cannot specialize non-generic type 'MyType<T, U>'}}
-    return TA<S>(a: t, b : s)
-  }
-}
-
-let _ = GenericStruct<Int>.TA<Float>(a: 4.0, b: 1)  // expected-error {{'Int' is not convertible to 'Float'}}
-
-let _ : GenericStruct<Int>.TA<Float>  // expected-error {{cannot specialize non-generic type 'MyType<Int, U>'}}
-
-
-
 extension A {}  // expected-error {{non-nominal type 'A' cannot be extended}}
 extension A<T> {}  // expected-error {{generic type 'A' specialized with too few type parameters (got 1, but expected 2)}}
 extension A<Float,Int> {}  // expected-error {{constrained extension must be declared on the unspecialized generic type 'MyType' with constraints specified by a 'where' clause}}