GSB: Move guts of getCanonicalTypeInContext() from GenericSignature to the GSB

Author: slavapestov

include/swift/AST/GenericSignature.h

@@ -362,8 +362,6 @@ class alignas(1 << TypeAlignInBits) GenericSignatureImpl final
   /// Return the canonical version of the given type under this generic
   /// signature.
   CanType getCanonicalTypeInContext(Type type) const;
-  CanType getCanonicalTypeInContext(Type type,
-                                    GenericSignatureBuilder &builder) const;
 
   bool isCanonicalTypeInContext(Type type) const;
   bool isCanonicalTypeInContext(Type type,

include/swift/AST/GenericSignatureBuilder.h

@@ -794,6 +794,13 @@ class GenericSignatureBuilder {
   /// Simplify the given dependent type down to its canonical representation.
   Type getCanonicalTypeParameter(Type type);
 
+  /// Replace any non-canonical dependent types in the given type with their
+  /// canonical representation. This is not a canonical type in the AST sense;
+  /// type sugar is preserved. The GenericSignature::getCanonicalTypeInContext()
+  /// method combines this with a subsequent getCanonicalType() call.
+  Type getCanonicalTypeInContext(Type type,
+                            TypeArrayView<GenericTypeParamType> genericParams);
+
   /// Verify the correctness of the given generic signature.
   ///
   /// This routine will test that the given generic signature is both minimal

lib/AST/GenericSignature.cpp

@@ -557,47 +557,6 @@ bool GenericSignatureImpl::isCanonicalTypeInContext(
   });
 }
 
-CanType GenericSignatureImpl::getCanonicalTypeInContext(
-    Type type, GenericSignatureBuilder &builder) const {
-  type = type->getCanonicalType();
-
-  // All the contextual canonicality rules apply to type parameters, so if the
-  // type doesn't involve any type parameters, it's already canonical.
-  if (!type->hasTypeParameter())
-    return CanType(type);
-
-  // Replace non-canonical type parameters.
-  type = type.transformRec([&](TypeBase *component) -> Optional<Type> {
-    if (!isa<GenericTypeParamType>(component) &&
-        !isa<DependentMemberType>(component))
-      return None;
-
-    // Find the equivalence class for this dependent type.
-    auto resolved = builder.maybeResolveEquivalenceClass(
-                      Type(component),
-                      ArchetypeResolutionKind::CompleteWellFormed,
-                      /*wantExactPotentialArchetype=*/false);
-    if (!resolved) return None;
-
-    if (auto concrete = resolved.getAsConcreteType())
-      return getCanonicalTypeInContext(concrete, builder);
-
-    auto equivClass = resolved.getEquivalenceClass(builder);
-    if (!equivClass) return None;
-
-    if (equivClass->concreteType) {
-      return getCanonicalTypeInContext(equivClass->concreteType, builder);
-    }
-
-    return equivClass->getAnchor(builder, getGenericParams());
-  });
-  
-  auto result = type->getCanonicalType();
-
-  assert(isCanonicalTypeInContext(result, builder));
-  return result;
-}
-
 CanType GenericSignatureImpl::getCanonicalTypeInContext(Type type) const {
   type = type->getCanonicalType();
 
@@ -607,7 +566,7 @@ CanType GenericSignatureImpl::getCanonicalTypeInContext(Type type) const {
     return CanType(type);
 
   auto &builder = *getGenericSignatureBuilder();
-  return getCanonicalTypeInContext(type, builder);
+  return builder.getCanonicalTypeInContext(type, { })->getCanonicalType();
 }
 
 ArrayRef<CanTypeWrapper<GenericTypeParamType>>

lib/AST/GenericSignatureBuilder.cpp

@@ -4030,6 +4030,51 @@ bool GenericSignatureBuilder::areInSameEquivalenceClass(Type type1,
     == resolveEquivalenceClass(type2, ArchetypeResolutionKind::WellFormed);
 }
 
+Type GenericSignatureBuilder::getCanonicalTypeInContext(Type type,
+                           TypeArrayView<GenericTypeParamType> genericParams) {
+  // All the contextual canonicality rules apply to type parameters, so if the
+  // type doesn't involve any type parameters, it's already canonical.
+  if (!type->hasTypeParameter())
+    return type;
+
+  // Replace non-canonical type parameters.
+  return type.transformRec([&](TypeBase *component) -> Optional<Type> {
+    if (!isa<GenericTypeParamType>(component) &&
+        !isa<DependentMemberType>(component))
+      return None;
+
+    // Find the equivalence class for this dependent type.
+    auto resolved = maybeResolveEquivalenceClass(
+                      Type(component),
+                      ArchetypeResolutionKind::CompleteWellFormed,
+                      /*wantExactPotentialArchetype=*/false);
+    if (!resolved) return None;
+
+    if (auto concrete = resolved.getAsConcreteType())
+      return getCanonicalTypeInContext(concrete, genericParams);
+
+    auto equivClass = resolved.getEquivalenceClass(*this);
+    if (!equivClass) return None;
+
+    // If there is a concrete type in this equivalence class, use that.
+    if (auto concrete = equivClass->concreteType) {
+      // .. unless it's recursive.
+      if (equivClass->recursiveConcreteType)
+        return ErrorType::get(Type(type));
+
+      // Prevent recursive substitution.
+      equivClass->recursiveConcreteType = true;
+      SWIFT_DEFER {
+        equivClass->recursiveConcreteType = false;
+      };
+
+      return getCanonicalTypeInContext(concrete, genericParams);
+    }
+
+    return equivClass->getAnchor(*this, genericParams);
+  });
+}
+
 TypeArrayView<GenericTypeParamType>
 GenericSignatureBuilder::getGenericParams() const {
   return TypeArrayView<GenericTypeParamType>(Impl->GenericParams);