Sema: Don't re-sugar the type in StructuralTypeRequest::evaluate()

(cherry picked from commit 1db69ab)

Author: slavapestov

lib/AST/RequirementMachine/RequirementLowering.cpp

@@ -1037,12 +1037,10 @@ TypeAliasRequirementsRequest::evaluate(Evaluator &evaluator,
 
   auto getStructuralType = [](TypeDecl *typeDecl) -> Type {
     if (auto typealias = dyn_cast<TypeAliasDecl>(typeDecl)) {
-      if (typealias->getUnderlyingTypeRepr() != nullptr) {
-        auto type = typealias->getStructuralType();
-        if (auto *aliasTy = cast<TypeAliasType>(type.getPointer()))
-          return aliasTy->getSinglyDesugaredType();
-        return type;
-      }
+      // If the type alias was parsed from a user-written type representation,
+      // request a structural type to avoid unnecessary type checking work.
+      if (typealias->getUnderlyingTypeRepr() != nullptr)
+        return typealias->getStructuralType();
       return typealias->getUnderlyingType();
     }
 

lib/Sema/TypeCheckGeneric.cpp

@@ -1090,30 +1090,36 @@ Type StructuralTypeRequest::evaluate(Evaluator &evaluator,
                                      ? TypeResolverContext::GenericTypeAliasDecl
                                      : TypeResolverContext::TypeAliasDecl));
 
+  auto parentDC = typeAlias->getDeclContext();
+  auto &ctx = parentDC->getASTContext();
+
+  auto underlyingTypeRepr = typeAlias->getUnderlyingTypeRepr();
+
   // This can happen when code completion is attempted inside
   // of typealias underlying type e.g. `typealias F = () -> Int#^TOK^#`
-  auto &ctx = typeAlias->getASTContext();
-  auto underlyingTypeRepr = typeAlias->getUnderlyingTypeRepr();
   if (!underlyingTypeRepr) {
     typeAlias->setInvalid();
     return ErrorType::get(ctx);
   }
 
-  const auto type =
-      TypeResolution::forStructural(typeAlias, options,
-                                    /*unboundTyOpener*/ nullptr,
-                                    /*placeholderHandler*/ nullptr,
-                                    /*packElementOpener*/ nullptr)
+  auto result = TypeResolution::forStructural(typeAlias, options,
+                                              /*unboundTyOpener*/ nullptr,
+                                              /*placeholderHandler*/ nullptr,
+                                              /*packElementOpener*/ nullptr)
           .resolveType(underlyingTypeRepr);
 
+  // Don't build a generic siganture for a protocol extension, because this
+  // request might be evaluated while building a protocol requirement signature.
+  if (parentDC->getSelfProtocolDecl())
+    return result;
+
   auto genericSig = typeAlias->getGenericSignature();
   SubstitutionMap subs;
   if (genericSig)
     subs = genericSig->getIdentitySubstitutionMap();
 
   Type parent;
-  auto parentDC = typeAlias->getDeclContext();
   if (parentDC->isTypeContext())
     parent = parentDC->getSelfInterfaceType();
-  return TypeAliasType::get(typeAlias, parent, subs, type);
+  return TypeAliasType::get(typeAlias, parent, subs, result);
 }