Setting the underlying type should set the structural type too

This avoids making the structural type dependent on whether the interface type has been computed and neatly avoids special-casing non-parsed declarations which set their underlying type up front.

Author: CodaFi

Diff for: lib/AST/ASTPrinter.cpp

@@ -2294,7 +2294,7 @@ void PrintAST::visitTypeAliasDecl(TypeAliasDecl *decl) {
     // preserving sugar.
     llvm::SaveAndRestore<GenericEnvironment*> setGenericEnv(Options.GenericEnv,
                                                 decl->getGenericEnvironment());
-    printTypeLoc(TypeLoc::withoutLoc(Ty));
+    printTypeLoc(TypeLoc(decl->getUnderlyingTypeRepr(), Ty));
     printGenericDeclGenericRequirements(decl);
   }
 }

Diff for: lib/AST/Decl.cpp

@@ -3553,6 +3553,13 @@ Type TypeAliasDecl::getUnderlyingType() const {
 }
 
 void TypeAliasDecl::setUnderlyingType(Type underlying) {
+  // lldb creates global typealiases containing archetypes
+  // sometimes...
+  if (underlying->hasArchetype() && isGenericContext())
+    underlying = underlying->mapTypeOutOfContext();
+  getASTContext().evaluator.cacheOutput(
+          StructuralTypeRequest{const_cast<TypeAliasDecl *>(this)},
+          std::move(underlying));
   getASTContext().evaluator.cacheOutput(
           UnderlyingTypeRequest{const_cast<TypeAliasDecl *>(this)},
           std::move(underlying));

Diff for: lib/AST/GenericSignatureBuilder.cpp

@@ -3785,8 +3785,6 @@ PotentialArchetype *GenericSignatureBuilder::realizePotentialArchetype(
 
 static Type getStructuralType(TypeDecl *typeDecl) {
   if (auto typealias = dyn_cast<TypeAliasDecl>(typeDecl)) {
-    if (typealias->hasInterfaceType())
-      return typealias->getDeclaredInterfaceType();
     return typealias->getStructuralType();
   }
 

Diff for: lib/AST/TypeCheckRequests.cpp

@@ -837,9 +837,5 @@ UnderlyingTypeRequest::getCachedResult() const {
 
 void UnderlyingTypeRequest::cacheResult(Type value) const {
   auto *typeAlias = std::get<0>(getStorage());
-  // lldb creates global typealiases containing archetypes
-  // sometimes...
-  if (value->hasArchetype() && typeAlias->isGenericContext())
-    value = value->mapTypeOutOfContext();
   typeAlias->UnderlyingTy.setType(value);
 }

Diff for: lib/Sema/TypeCheckDecl.cpp

@@ -3492,14 +3492,14 @@ UnderlyingTypeRequest::evaluate(Evaluator &evaluator,
     return ErrorType::get(typeAlias->getASTContext());
   }
 
-  if (TypeChecker::validateType(typeAlias->getASTContext(),
-                                typeAlias->getUnderlyingTypeLoc(),
+  auto underlyingLoc = TypeLoc(typeAlias->getUnderlyingTypeRepr());
+  if (TypeChecker::validateType(typeAlias->getASTContext(), underlyingLoc,
                                 TypeResolution::forInterface(typeAlias),
                                 options)) {
     typeAlias->setInvalid();
     return ErrorType::get(typeAlias->getASTContext());
   }
-  return ty;
+  return underlyingLoc.getType();
 }
 
 /// Bind the given function declaration, which declares an operator, to the corresponding operator declaration.

Diff for: lib/Sema/TypeCheckGeneric.cpp

@@ -966,14 +966,7 @@ RequirementRequest::evaluate(Evaluator &evaluator,
 
 llvm::Expected<Type>
 StructuralTypeRequest::evaluate(Evaluator &evaluator,
-                                TypeAliasDecl *typeAlias) const {
-  // Fast path: If the interface type is already resolved, there's no need
-  // to compute the structural type.  This also prevents us from writing
-  // ErrorTypes into otherwise valid ASTs with generated typealiases.
-  if (typeAlias->hasInterfaceType()) {
-    return typeAlias->getInterfaceType()->getMetatypeInstanceType();
-  }
-  
+                                TypeAliasDecl *typeAlias) const {  
   TypeResolutionOptions options((typeAlias->getGenericParams()
                                      ? TypeResolverContext::GenericTypeAliasDecl
                                      : TypeResolverContext::TypeAliasDecl));